couchrest 0.38 → 1.0.0.beta

data/lib/couchrest/mixins/views.rb

@@ -1,173 +0,0 @@
-module CouchRest
-  module Mixins
-    module Views
-      
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-      
-      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['couchrest-type'] == '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['couchrest-type'] == '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['couchrest-type'] == '#{self.to_s}')"
-          end
-          keys.push opts
-          self.design_doc.view_by(*keys)
-          self.design_doc_fresh = false
-        end
-
-        # returns stored defaults if the there is a view named this in the design doc
-        def has_view?(view)
-          view = view.to_s
-          design_doc && design_doc['views'] && design_doc['views'][view]
-        end
-
-        # Dispatches to any named view.
-        def view(name, query={}, &block)
-          db = query.delete(:database) || database
-          unless design_doc_fresh            
-            refresh_design_doc_on(db)
-          end
-          query[:raw] = true if query[:reduce]        
-          raw = query.delete(:raw)
-          fetch_view_with_docs(db, name, query, raw, &block)
-        end
-
-        # DEPRECATED
-        # user model_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
-        
-        def model_design_doc(db = database)
-          begin
-            @model_design_doc = db.get("_design/#{self.to_s}")
-          rescue
-            nil
-          end
-        end
-
-        # Deletes the current design doc for the current class.
-        # Running it to early could mean that live code has to regenerate
-        # potentially large indexes.
-        def cleanup_design_docs!(db = database)
-          save_design_doc_on(db)
-        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
-            begin
-              if block.nil?
-                collection_proxy_for(design_doc, name, opts.merge({:include_docs => true}))
-              else
-                view = fetch_view db, name, opts.merge({:include_docs => true}), &block
-                view['rows'].collect{|r|create_from_database(r['doc'])} if view['rows']
-              end
-            rescue
-              # fallback for old versions of couchdb that don't 
-              # have include_docs support
-              view = fetch_view(db, name, opts, &block)
-              view['rows'].collect{|r|create_from_database(db.get(r['id']))} if view['rows']
-            end
-          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
-          retryable = true
-          begin
-            design_doc.view_on(db, view_name, opts, &block)
-            # the design doc may not have been saved yet on this database
-          rescue HttpAbstraction::ResourceNotFound => e
-            if retryable
-              save_design_doc_on(db)
-              retryable = false
-              retry
-            else
-              raise e
-            end
-          end
-        end
-        
-      end # module ClassMethods
-      
-      
-    end
-  end
-end

data/lib/couchrest/more/casted_model.rb

@@ -1,58 +0,0 @@
-require File.expand_path('../../mixins/properties', __FILE__)
-
-
-module CouchRest
-  module CastedModel
-    
-    def self.included(base)
-      base.send(:include, ::CouchRest::Callbacks)
-      base.send(:include, ::CouchRest::Mixins::Properties)
-      base.send(:attr_accessor, :casted_by)
-      base.send(:attr_accessor, :document_saved)
-    end
-    
-    def initialize(keys={})
-      raise StandardError unless self.is_a? Hash
-      apply_defaults # defined in CouchRest::Mixins::Properties
-      super()
-      keys.each do |k,v|
-        self[k.to_s] = v
-      end if keys
-      cast_keys      # defined in CouchRest::Mixins::Properties
-    end
-    
-    def []= key, value
-      super(key.to_s, value)
-    end
-    
-    def [] key
-      super(key.to_s)
-    end
-    
-    # Gets a reference to the top level extended
-    # document that a model is saved inside of
-    def base_doc
-      return nil unless @casted_by
-      @casted_by.base_doc
-    end
-    
-    # False if the casted model has already
-    # been saved in the containing document
-    def new?
-      !@document_saved
-    end
-    alias :new_record? :new?
-    
-    # Sets the attributes from a hash
-    def update_attributes_without_saving(hash)
-      hash.each do |k, v|
-        raise NoMethodError, "#{k}= method not available, use property :#{k}" unless self.respond_to?("#{k}=")
-      end      
-      hash.each do |k, v|
-        self.send("#{k}=",v)
-      end
-    end
-    alias :attributes= :update_attributes_without_saving
-    
-  end
-end

data/lib/couchrest/more/extended_document.rb

@@ -1,310 +0,0 @@
-require 'mime/types'
-require File.join(File.dirname(__FILE__), "property")
-require File.join(File.dirname(__FILE__), '..', 'mixins', 'extended_document_mixins')
-require "enumerator"
-
-module CouchRest
-  
-  # Same as CouchRest::Document but with properties and validations
-  class ExtendedDocument < Document
-    include CouchRest::Callbacks
-    include CouchRest::Mixins::DocumentQueries    
-    include CouchRest::Mixins::Views
-    include CouchRest::Mixins::DesignDoc
-    include CouchRest::Mixins::ExtendedAttachments
-    include CouchRest::Mixins::ClassProxy
-    include CouchRest::Mixins::Collection
-    include CouchRest::Mixins::AttributeProtection
-
-    def self.subclasses
-      @subclasses ||= []
-    end
-    
-    def self.inherited(subklass)
-      super
-      subklass.send(:include, CouchRest::Mixins::Properties)
-      subklass.class_eval <<-EOS, __FILE__, __LINE__ + 1
-        def self.inherited(subklass)
-          super
-          subklass.properties = self.properties.dup
-        end
-      EOS
-      subclasses << subklass
-    end
-    
-    # Accessors
-    attr_accessor :casted_by
-    
-    # Callbacks
-    define_callbacks :create, "result == :halt"
-    define_callbacks :save, "result == :halt"
-    define_callbacks :update, "result == :halt"
-    define_callbacks :destroy, "result == :halt"
-
-    # Creates a new instance, bypassing attribute protection
-    #
-    # ==== Returns
-    #  a document instance
-    def self.create_from_database(passed_keys={})
-      new(passed_keys, :directly_set_attributes => true)      
-    end
-    
-    def initialize(passed_keys={}, options={})
-      apply_defaults # defined in CouchRest::Mixins::Properties
-      remove_protected_attributes(passed_keys) unless options[:directly_set_attributes]
-      directly_set_attributes(passed_keys) unless passed_keys.nil?
-      super(passed_keys)
-      cast_keys      # defined in CouchRest::Mixins::Properties
-      unless self['_id'] && self['_rev']
-        self['couchrest-type'] = self.class.to_s
-      end
-      after_initialize if respond_to?(:after_initialize)
-    end
-    
-    # Defines an instance and save it directly to the database 
-    # 
-    # ==== Returns
-    #  returns the reloaded document
-    def self.create(options)
-      instance = new(options)
-      instance.create
-      instance
-    end
-    
-    # Defines an instance and save it directly to the database 
-    # 
-    # ==== Returns
-    #  returns the reloaded document or raises an exception
-    def self.create!(options)
-      instance = new(options)
-      instance.create!
-      instance
-    end
-    
-    # Automatically set <tt>updated_at</tt> and <tt>created_at</tt> fields
-    # on the document whenever saving occurs. CouchRest uses a pretty
-    # decent time format by default. See Time#to_json
-    def self.timestamps!
-      class_eval <<-EOS, __FILE__, __LINE__
-        property(:updated_at, :read_only => true, :type => 'Time', :auto_validation => false)
-        property(:created_at, :read_only => true, :type => 'Time', :auto_validation => false)
-        
-        set_callback :save, :before do |object|
-          object['updated_at'] = Time.now
-          object['created_at'] = object['updated_at'] if object.new?
-        end
-      EOS
-    end
-    
-    # Name a method that will be called before the document is first saved,
-    # which returns a string to be used for the document's <tt>_id</tt>.
-    # Because CouchDB enforces a constraint that each id must be unique,
-    # this can be used to enforce eg: uniq usernames. Note that this id
-    # must be globally unique across all document types which share a
-    # database, so if you'd like to scope uniqueness to this class, you
-    # should use the class name as part of the unique id.
-    def self.unique_id method = nil, &block
-      if method
-        define_method :set_unique_id do
-          self['_id'] ||= self.send(method)
-        end
-      elsif block
-        define_method :set_unique_id do
-          uniqid = block.call(self)
-          raise ArgumentError, "unique_id block must not return nil" if uniqid.nil?
-          self['_id'] ||= uniqid
-        end
-      end
-    end
-    
-    # Temp solution to make the view_by methods available
-    def self.method_missing(m, *args, &block)
-      if has_view?(m)
-        query = args.shift || {}
-        view(m, query, *args, &block)
-      else
-        super
-      end
-    end
-    
-    ### instance methods
-    
-    # Returns the Class properties
-    #
-    # ==== Returns
-    # Array:: the list of properties for the instance
-    def properties
-      self.class.properties
-    end
-    
-    # Gets a reference to the actual document in the DB
-    # Calls up to the next document if there is one,
-    # Otherwise we're at the top and we return self
-    def base_doc
-      return self if base_doc?
-      @casted_by.base_doc
-    end
-    
-    # Checks if we're the top document
-    def base_doc?
-      !@casted_by
-    end
-    
-    # Takes a hash as argument, and applies the values by using writer methods
-    # for each key. It doesn't save the document at the end. Raises a NoMethodError if the corresponding methods are
-    # missing. In case of error, no attributes are changed.    
-    def update_attributes_without_saving(hash)
-      # remove attributes that cannot be updated, silently ignoring them
-      # which matches Rails behavior when, for instance, setting created_at.
-      # make a copy, we don't want to change arguments
-      attrs = hash.dup
-      %w[_id _rev created_at updated_at].each {|attr| attrs.delete(attr)}
-      check_properties_exist(attrs)
-			set_attributes(attrs)
-    end
-    alias :attributes= :update_attributes_without_saving
-
-    # Takes a hash as argument, and applies the values by using writer methods
-    # for each key. Raises a NoMethodError if the corresponding methods are
-    # missing. In case of error, no attributes are changed.
-    def update_attributes(hash)
-      update_attributes_without_saving hash
-      save
-    end
-
-    # for compatibility with old-school frameworks
-    alias :new_record? :new?
-    alias :new_document? :new?
-    
-    # Trigger the callbacks (before, after, around)
-    # and create the document
-    # It's important to have a create callback since you can't check if a document
-    # was new after you saved it
-    #
-    # When creating a document, both the create and the save callbacks will be triggered.
-    def create(bulk = false)
-      caught = catch(:halt)  do
-        _run_create_callbacks do
-            _run_save_callbacks do
-              create_without_callbacks(bulk)
-          end
-        end
-      end
-    end
-    
-    # unlike save, create returns the newly created document
-    def create_without_callbacks(bulk =false)
-      raise ArgumentError, "a document requires a database to be created to (The document or the #{self.class} default database were not set)" unless database
-      set_unique_id if new? && self.respond_to?(:set_unique_id)
-      result = database.save_doc(self, bulk)
-      (result["ok"] == true) ? self : false
-    end
-    
-    # Creates the document in the db. Raises an exception
-    # if the document is not created properly.
-    def create!
-      raise "#{self.inspect} failed to save" unless self.create
-    end
-    
-    # Trigger the callbacks (before, after, around)
-    # only if the document isn't new
-    def update(bulk = false)
-      caught = catch(:halt)  do
-        if self.new?
-          save(bulk)
-        else
-          _run_update_callbacks do
-            _run_save_callbacks do
-              save_without_callbacks(bulk)
-            end
-          end
-        end
-      end
-    end
-    
-    # Trigger the callbacks (before, after, around)
-    # and save the document
-    def save(bulk = false)
-      caught = catch(:halt)  do
-        if self.new?
-          _run_save_callbacks do
-            save_without_callbacks(bulk)
-          end
-        else
-          update(bulk)
-        end
-      end
-    end
-    
-    # Overridden to set the unique ID.
-    # Returns a boolean value
-    def save_without_callbacks(bulk = false)
-      raise ArgumentError, "a document requires a database to be saved to (The document or the #{self.class} default database were not set)" unless database
-      set_unique_id if new? && self.respond_to?(:set_unique_id)
-      result = database.save_doc(self, bulk)
-      mark_as_saved 
-      result["ok"] == true
-    end
-    
-    # Saves the document to the db using save. Raises an exception
-    # if the document is not saved properly.
-    def save!
-      raise "#{self.inspect} failed to save" unless self.save
-      true
-    end
-
-    # Deletes the document from the database. Runs the :destroy callbacks.
-    # Removes the <tt>_id</tt> and <tt>_rev</tt> fields, preparing the
-    # document to be saved to a new <tt>_id</tt>.
-    def destroy(bulk=false)
-      caught = catch(:halt)  do
-        _run_destroy_callbacks do
-          result = database.delete_doc(self, bulk)
-          if result['ok']
-            self.delete('_rev')
-            self.delete('_id')
-          end
-          result['ok']
-        end
-      end
-    end
-    
-    protected
-    
-    # Set document_saved flag on all casted models to true
-    def mark_as_saved
-      self.each do |key, prop|
-        if prop.is_a?(Array)
-          prop.each do |item|
-            if item.respond_to?(:document_saved)
-              item.send(:document_saved=, true)
-            end
-          end
-        elsif prop.respond_to?(:document_saved)
-          prop.send(:document_saved=, true)
-        end
-      end
-    end
-
-		private
-
-		def check_properties_exist(attrs)
-      attrs.each do |attribute_name, attribute_value|
-        raise NoMethodError, "#{attribute_name}= method not available, use property :#{attribute_name}" unless self.respond_to?("#{attribute_name}=")
-      end      
-		end
-    
-    def directly_set_attributes(hash)
-      hash.each do |attribute_name, attribute_value|
-        if self.respond_to?("#{attribute_name}=")
-          self.send("#{attribute_name}=", hash.delete(attribute_name))
-        end
-      end
-    end
-    
-		def set_attributes(hash)
-			attrs = remove_protected_attributes(hash)
-			directly_set_attributes(attrs)
-		end
-  end
-end