couchrest_extended_document 1.0.0.beta5

data/lib/couchrest/mixins/collection.rb

@@ -0,0 +1,260 @@
+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

@@ -0,0 +1,127 @@
+require 'digest/md5'
+
+module CouchRest
+  module Mixins
+    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/mixins/document_queries.rb

@@ -0,0 +1,82 @@
+module CouchRest
+  module Mixins
+    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

data/lib/couchrest/mixins/extended_attachments.rb

@@ -0,0 +1,73 @@
+module CouchRest
+  module Mixins
+    module ExtendedAttachments
+
+      # Add a file attachment to the current document. Expects
+      # :file and :name to be included in the arguments.
+      def create_attachment(args={})
+        raise ArgumentError unless args[:file] && args[:name]
+        return if has_attachment?(args[:name])
+        self['_attachments'] ||= {}
+        set_attachment_attr(args)
+      rescue ArgumentError => e
+        raise ArgumentError, 'You must specify :file and :name'
+      end
+
+      # reads the data from an attachment
+      def read_attachment(attachment_name)
+        database.fetch_attachment(self, attachment_name)
+      end
+
+      # modifies a file attachment on the current doc
+      def update_attachment(args={})
+        raise ArgumentError unless args[:file] && args[:name]
+        return unless has_attachment?(args[:name])
+        delete_attachment(args[:name])
+        set_attachment_attr(args)
+      rescue ArgumentError => e
+        raise ArgumentError, 'You must specify :file and :name'
+      end
+
+      # deletes a file attachment from the current doc
+      def delete_attachment(attachment_name)
+        return unless self['_attachments']
+        self['_attachments'].delete attachment_name
+      end
+
+      # returns true if attachment_name exists
+      def has_attachment?(attachment_name)
+        !!(self['_attachments'] && self['_attachments'][attachment_name] && !self['_attachments'][attachment_name].empty?)
+      end
+
+      # returns URL to fetch the attachment from
+      def attachment_url(attachment_name)
+        return unless has_attachment?(attachment_name)
+        "#{database.root}/#{self.id}/#{attachment_name}"
+      end
+      
+      # returns URI to fetch the attachment from
+      def attachment_uri(attachment_name)
+        return unless has_attachment?(attachment_name)
+        "#{database.uri}/#{self.id}/#{attachment_name}"
+      end
+      
+      private
+      
+        def get_mime_type(path)
+          return nil if path.nil?
+          type = ::MIME::Types.type_for(path)
+          type.empty? ? nil : type.first.content_type
+        end
+
+        def set_attachment_attr(args)
+          content_type = args[:content_type] ? args[:content_type] : get_mime_type(args[:file].path)
+          content_type ||= (get_mime_type(args[:name]) || 'text/plain')
+          self['_attachments'][args[:name]] = {
+            'content_type' => content_type,
+            'data'         => args[:file].read
+          }
+        end
+      
+    end # module ExtendedAttachments
+  end
+end

data/lib/couchrest/mixins/properties.rb

@@ -0,0 +1,162 @@
+require 'time'
+require File.join(File.dirname(__FILE__), '..', 'property')
+require File.join(File.dirname(__FILE__), '..', 'casted_array')
+require File.join(File.dirname(__FILE__), '..', 'typecast')
+
+module CouchRest
+  module Mixins
+    module Properties
+      
+      class IncludeError < StandardError; end
+      
+      include ::CouchRest::More::Typecast
+
+      def self.included(base)
+        base.class_eval <<-EOS, __FILE__, __LINE__ + 1
+            extlib_inheritable_accessor(:properties) unless self.respond_to?(:properties)
+            self.properties ||= []
+        EOS
+        base.extend(ClassMethods)
+        raise CouchRest::Mixins::Properties::IncludeError, "You can only mixin Properties in a class responding to [] and []=, if you tried to mixin CastedModel, make sure your class inherits from Hash or responds to the proper methods" unless (base.new.respond_to?(:[]) && base.new.respond_to?(:[]=))
+      end
+      
+      def apply_defaults
+        return if self.respond_to?(:new?) && (new? == false)
+        return unless self.class.respond_to?(:properties) 
+        return if self.class.properties.empty?
+        # TODO: cache the default object
+        self.class.properties.each do |property|
+          key = property.name.to_s
+          # let's make sure we have a default
+          unless property.default.nil?
+              if property.default.class == Proc
+                self[key] = property.default.call
+              else
+                self[key] = Marshal.load(Marshal.dump(property.default))
+              end
+            end
+        end
+      end
+      
+      def cast_keys
+        return unless self.class.properties
+        self.class.properties.each do |property|
+          cast_property(property)
+        end
+      end
+      
+      def cast_property(property, assigned=false)
+        return unless property.casted
+        key = self.has_key?(property.name) ? property.name : property.name.to_sym
+        # Don't cast the property unless it has a value
+        return unless self[key]
+        if property.type.is_a?(Array)
+          klass = property.type[0]
+          self[key] = [self[key]] unless self[key].is_a?(Array)
+          arr = self[key].collect do |value|
+            value = typecast_value(value, klass, property.init_method)
+            associate_casted_to_parent(value, assigned)
+            value
+          end
+          # allow casted_by calls to be passed up chain by wrapping in CastedArray
+          self[key] = klass != String ? ::CouchRest::CastedArray.new(arr) : arr
+          self[key].casted_by = self if self[key].respond_to?(:casted_by)
+        else
+          self[key] = typecast_value(self[key], property.type, property.init_method)
+          associate_casted_to_parent(self[key], assigned)
+        end
+      end
+      
+      def associate_casted_to_parent(casted, assigned)
+        casted.casted_by = self if casted.respond_to?(:casted_by)
+        casted.document_saved = true if !assigned && casted.respond_to?(:document_saved)
+      end
+      
+      def cast_property_by_name(property_name)
+        return unless self.class.properties
+        property = self.class.properties.detect{|property| property.name == property_name}
+        return unless property
+        cast_property(property, true)
+      end
+      
+     
+      module ClassMethods
+        
+        def property(name, *options)
+          opts = { }
+          type = options.shift
+          if type.class != Hash
+            opts[:type] = type
+            opts.merge!(options.shift || {})
+          else
+            opts.update(type)
+          end
+          existing_property = self.properties.find{|p| p.name == name.to_s}
+          if existing_property.nil? || (existing_property.default != opts[:default])
+            define_property(name, opts)
+          end
+        end
+        
+        protected
+        
+          # This is not a thread safe operation, if you have to set new properties at runtime
+          # make sure to use a mutex.
+          def define_property(name, options={})
+            # check if this property is going to casted
+            options[:casted] = !!(options[:cast_as] || options[:type])
+            property = CouchRest::Property.new(name, (options.delete(:cast_as) || options.delete(:type)), options)
+            create_property_getter(property) 
+            create_property_setter(property) unless property.read_only == true
+            properties << property
+          end
+          
+          # defines the getter for the property (and optional aliases)
+          def create_property_getter(property)
+            # meth = property.name
+            class_eval <<-EOS, __FILE__, __LINE__ + 1
+              def #{property.name}
+                self['#{property.name}']
+              end
+            EOS
+
+            if ['boolean', TrueClass.to_s.downcase].include?(property.type.to_s.downcase)
+              class_eval <<-EOS, __FILE__, __LINE__
+                def #{property.name}?
+                  if self['#{property.name}'].nil? || self['#{property.name}'] == false
+                    false
+                  else
+                    true
+                  end
+                end
+              EOS
+            end
+
+            if property.alias
+              class_eval <<-EOS, __FILE__, __LINE__ + 1
+                alias #{property.alias.to_sym} #{property.name.to_sym}
+              EOS
+            end
+          end
+
+          # defines the setter for the property (and optional aliases)
+          def create_property_setter(property)
+            property_name = property.name
+            class_eval <<-EOS
+              def #{property_name}=(value)
+                self['#{property_name}'] = value
+                cast_property_by_name('#{property_name}')
+              end
+            EOS
+
+            if property.alias
+              class_eval <<-EOS
+                alias #{property.alias.to_sym}= #{property_name.to_sym}=
+              EOS
+            end
+          end
+          
+      end # module ClassMethods
+      
+    end
+  end
+end