derfred-couchrest 0.12.6 → 0.12.6.3

data/lib/couchrest.rb

@@ -25,7 +25,7 @@ require 'couchrest/monkeypatches'
 
 # = CouchDB, close to the metal
 module CouchRest
-  VERSION = '0.12.6'
+  VERSION = '0.12.6.3'
   
   autoload :Server,       'couchrest/core/server'
   autoload :Database,     'couchrest/core/database'

data/lib/couchrest/core/database.rb

@@ -61,14 +61,31 @@ module CouchRest
     # paramaters as described in http://wiki.apache.org/couchdb/HttpViewApi
     def view(name, params = {}, &block)
       keys = params.delete(:keys)
+      stripes = params.delete(:stripes)
+      raw = params.delete(:raw)
       url = CouchRest.paramify_url "#{@uri}/_view/#{name}", params
-      if keys
-        CouchRest.post(url, {:keys => keys})
+      case
+      when keys
+        if raw
+          CouchRest.post_raw(url, {:keys => keys})
+        else
+          CouchRest.post(url, {:keys => keys})
+        end
+      when stripes
+        if raw
+          CouchRest.post_raw(url, {:stripes => stripes})
+        else
+          CouchRest.post(url, {:stripes => stripes})
+        end
       else
         if block_given?
           @streamer.view(name, params, &block)
         else
-          CouchRest.get url
+          if raw
+            CouchRest.get_raw url
+          else
+            CouchRest.get url
+          end
         end
       end
     end

data/lib/couchrest/helper/file_manager.rb

@@ -0,0 +1,309 @@
+require 'digest/md5'
+ 
+module CouchRest
+  class FileManager
+    attr_reader :db
+    attr_accessor :loud
+    
+    LANGS = {"rb" => "ruby", "js" => "javascript"}
+    MIMES = {
+      "html" => "text/html",
+      "htm" => "text/html",
+      "png" => "image/png",
+      "gif" => "image/gif",
+      "css" => "text/css",
+      "js" => "test/javascript",
+      "txt" => "text/plain"
+    }
+ 
+    # Generate an application in the given directory.
+    # This is a class method because it doesn't depend on
+    # specifying a database.
+    def self.generate_app(app_dir)
+      templatedir = File.join(File.expand_path(File.dirname(__FILE__)), 'app-template')
+      FileUtils.cp_r(templatedir, app_dir)
+    end
+     
+    # instance methods
+     
+    def initialize(dbname, host="http://127.0.0.1:5984")
+      @db = CouchRest.new(host).database(dbname)
+    end
+    
+    # maintain the correspondence between an fs and couch
+    
+    def push_app(appdir, appname)
+      libs = []
+      viewdir = File.join(appdir,"views")
+      attachdir = File.join(appdir,"_attachments")
+ 
+      @doc = dir_to_fields(appdir)
+      package_forms(@doc["forms"]) if @doc['forms']
+      package_views(@doc["views"]) if @doc['views']
+ 
+      docid = "_design/#{appname}"
+      design = @db.get(docid) rescue {}
+      design.merge!(@doc)
+      design['_id'] = docid
+      # design['language'] = lang if lang
+      @db.save(design)
+      push_directory(attachdir, docid)
+    end
+    
+    def dir_to_fields(dir)
+      fields = {}
+      (Dir["#{dir}/**/*.*"] -
+        Dir["#{dir}/_attachments/**/*.*"]).each do |file|
+        farray = file.sub(dir, '').sub(/^\//,'').split('/')
+        myfield = fields
+        while farray.length > 1
+          front = farray.shift
+          myfield[front] ||= {}
+          myfield = myfield[front]
+        end
+        fname, fext = farray.shift.split('.')
+        fguts = File.open(file).read
+        if fext == 'json'
+          myfield[fname] = JSON.parse(fguts)
+        else
+          myfield[fname] = fguts
+        end
+      end
+      return fields
+    end
+    
+    def push_directory(push_dir, docid=nil)
+      docid ||= push_dir.split('/').reverse.find{|part|!part.empty?}
+ 
+      pushfiles = Dir["#{push_dir}/**/*.*"].collect do |f|
+        {f.split("#{push_dir}/").last => open(f).read}
+      end
+ 
+      return if pushfiles.empty?
+ 
+      @attachments = {}
+      @signatures = {}
+      pushfiles.each do |file|
+        name = file.keys.first
+        value = file.values.first
+        @signatures[name] = md5(value)
+ 
+        @attachments[name] = {
+          "data" => value,
+          "content_type" => MIMES[name.split('.').last]
+        }
+      end
+ 
+      doc = @db.get(docid) rescue nil
+ 
+      unless doc
+        say "creating #{docid}"
+        @db.save({"_id" => docid, "_attachments" => @attachments, "signatures" => @signatures})
+        return
+      end
+ 
+      doc["signatures"] ||= {}
+      doc["_attachments"] ||= {}
+      # remove deleted docs
+      to_be_removed = doc["signatures"].keys.select do |d|
+        !pushfiles.collect{|p| p.keys.first}.include?(d)
+      end
+ 
+      to_be_removed.each do |p|
+        say "deleting #{p}"
+        doc["signatures"].delete(p)
+        doc["_attachments"].delete(p)
+      end
+ 
+      # update existing docs:
+      doc["signatures"].each do |path, sig|
+        if (@signatures[path] == sig)
+          say "no change to #{path}. skipping..."
+        else
+          say "replacing #{path}"
+          doc["signatures"][path] = md5(@attachments[path]["data"])
+          doc["_attachments"][path].delete("stub")
+          doc["_attachments"][path].delete("length")
+          doc["_attachments"][path]["data"] = @attachments[path]["data"]
+          doc["_attachments"][path].merge!({"data" => @attachments[path]["data"]} )
+        end
+      end
+ 
+      # add in new files
+      new_files = pushfiles.select{|d| !doc["signatures"].keys.include?( d.keys.first) }
+ 
+      new_files.each do |f|
+        say "creating #{f}"
+        path = f.keys.first
+        content = f.values.first
+        doc["signatures"][path] = md5(content)
+ 
+        doc["_attachments"][path] = {
+          "data" => content,
+          "content_type" => MIMES[path.split('.').last]
+        }
+      end
+ 
+      begin
+        @db.save(doc)
+      rescue Exception => e
+        say e.message
+      end
+    end
+
+    def push_views(view_dir)
+      designs = {}
+    
+      Dir["#{view_dir}/**/*.*"].each do |design_doc|
+        design_doc_parts = design_doc.split('/')
+        next if /^lib\..*$/.match design_doc_parts.last
+        pre_normalized_view_name = design_doc_parts.last.split("-")
+        view_name = pre_normalized_view_name[0..pre_normalized_view_name.length-2].join("-")
+    
+        folder = design_doc_parts[-2]
+    
+        designs[folder] ||= {}
+        designs[folder]["views"] ||= {}
+        design_lang = design_doc_parts.last.split(".").last
+        designs[folder]["language"] ||= LANGS[design_lang]
+    
+        libs = ""
+        Dir["#{view_dir}/lib.#{design_lang}"].collect do |global_lib|
+          libs << open(global_lib).read
+          libs << "\n"
+        end
+        Dir["#{view_dir}/#{folder}/lib.#{design_lang}"].collect do |global_lib|
+          libs << open(global_lib).read
+          libs << "\n"
+        end
+        if design_doc_parts.last =~ /-map/
+          designs[folder]["views"][view_name] ||= {}
+          designs[folder]["views"][view_name]["map"] = read(design_doc, libs)
+        end
+    
+        if design_doc_parts.last =~ /-reduce/
+          designs[folder]["views"][view_name] ||= {}
+          designs[folder]["views"][view_name]["reduce"] = read(design_doc, libs)
+        end
+      end
+    
+      # cleanup empty maps and reduces
+      designs.each do |name, props|
+        props["views"].each do |view, funcs|
+          next unless view.include?("reduce")
+          props["views"].delete(view) unless funcs.keys.include?("reduce")
+        end
+      end
+    
+      designs.each do |k,v|
+        create_or_update("_design/#{k}", v)
+      end
+    
+      designs
+    end
+
+    private
+
+    def read(file, libs=nil)
+      st = open(file).read
+      st.sub!(/(\/\/|#)include-lib/,libs) if libs
+      st
+    end
+
+    def create_or_update(id, fields)
+      existing = @db.get(id) rescue nil
+
+      if existing
+        updated = existing.merge(fields)
+        if existing != updated
+          say "replacing #{id}"
+          db.save(updated)
+        else
+          say "skipping #{id}"
+        end
+      else
+        say "creating #{id}"
+        db.save(fields.merge({"_id" => id}))
+      end
+    
+    end
+
+
+    def package_forms(funcs)
+      apply_lib(funcs)
+    end
+    
+    def package_views(views)
+      views.each do |view, funcs|
+        apply_lib(funcs)
+      end
+    end
+    
+    def apply_lib(funcs)
+      funcs.each do |k,v|
+        next unless v.is_a?(String)
+        funcs[k] = process_include(process_require(v))
+      end
+    end
+    
+    # process requires
+    def process_require(f_string)
+      f_string.gsub /(\/\/|#)\ ?!code (.*)/ do
+        fields = $2.split('.')
+        library = @doc
+        fields.each do |field|
+          library = library[field]
+          break unless library
+        end
+        library
+      end
+    end
+    
+    
+    def process_include(f_string)
+ 
+      # process includes
+      included = {}
+      f_string.gsub /(\/\/|#)\ ?!json (.*)/ do
+        fields = $2.split('.')
+        library = @doc
+        include_to = included
+        count = fields.length
+        fields.each_with_index do |field, i|
+          break unless library[field]
+          library = library[field]
+          # normal case
+          if i+1 < count
+            include_to[field] = include_to[field] || {}
+            include_to = include_to[field]
+          else
+            # last one
+            include_to[field] = library
+          end
+        end
+ 
+      end
+      # puts included.inspect
+      rval = if included == {}
+        f_string
+      else
+        varstrings = included.collect do |k, v|
+          "var #{k} = #{v.to_json};"
+        end
+        # just replace the first instance of the macro
+        f_string.sub /(\/\/|#)\ ?!json (.*)/, varstrings.join("\n")
+      end
+      
+      rval
+    end
+    
+    
+    def say words
+      puts words if @loud
+    end
+    
+    def md5 string
+      Digest::MD5.hexdigest(string)
+    end
+  end
+end

data/lib/couchrest/mixins.rb

@@ -0,0 +1,3 @@
+mixins_dir = File.join(File.dirname(__FILE__), 'mixins')
+
+require File.join(mixins_dir, 'views')

data/lib/couchrest/mixins/design_doc.rb

@@ -0,0 +1,63 @@
+require 'digest/md5'
+
+module CouchRest
+  module Mixins
+    module DesignDoc
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        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
+          md5 = Digest::MD5.hexdigest(funcs.sort.join(''))
+          self.design_doc_slug_cache = "#{self.to_s}-#{md5}"
+        end
+
+        def default_design_doc
+          {
+            "language" => "javascript",
+            "views" => {
+              'all' => {
+                'map' => "function(doc) {
+                  if (doc['couchrest-type'] == '#{self.to_s}') {
+                    emit(null,null);
+                  }
+                }"
+              }
+            }
+          }
+        end
+
+        def refresh_design_doc
+          did = design_doc_id
+          saved = database.get(did) rescue nil
+          if saved
+            design_doc['views'].each do |name, view|
+              saved['views'][name] = view
+            end
+            database.save_doc(saved)
+            self.design_doc = saved
+          else
+            design_doc['_id'] = did
+            design_doc.delete('_rev')
+            design_doc.database = database
+            design_doc.save
+          end
+          self.design_doc_fresh = true
+        end
+        
+      end # module ClassMethods
+      
+    end
+  end
+end

data/lib/couchrest/mixins/document_queries.rb

@@ -0,0 +1,48 @@
+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)
+          self.design_doc ||= Design.new(default_design_doc)
+          unless design_doc_fresh
+            refresh_design_doc
+          end
+          view :all, opts, &block
+        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
+        def get(id)
+          doc = database.get id
+          new(doc)
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/couchrest/mixins/extended_document_mixins.rb

@@ -0,0 +1,4 @@
+require File.join(File.dirname(__FILE__), 'properties')
+require File.join(File.dirname(__FILE__), 'document_queries')
+require File.join(File.dirname(__FILE__), 'extended_views')
+require File.join(File.dirname(__FILE__), 'design_doc')

data/lib/couchrest/mixins/extended_views.rb

@@ -0,0 +1,169 @@
+module CouchRest
+  module Mixins
+    module ExtendedViews
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+        # extlib is required for the following code
+        base.send(:class_inheritable_accessor, :design_doc)
+        base.send(:class_inheritable_accessor, :design_doc_slug_cache)
+        base.send(:class_inheritable_accessor, :design_doc_fresh)
+      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.
+        #  
+        # 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 compeletly,
+        # it is recommended that you read the RSpec file at
+        # <tt>spec/core/model_spec.rb</tt>.
+
+        def view_by(*keys)
+          self.design_doc ||= Design.new(default_design_doc)
+          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
+          unless design_doc_fresh
+            refresh_design_doc
+          end
+          query[:raw] = true if query[:reduce]        
+          raw = query.delete(:raw)
+          fetch_view_with_docs(name, query, raw, &block)
+        end
+
+        def all_design_doc_versions
+          database.documents :startkey => "_design/#{self.to_s}-", 
+            :endkey => "_design/#{self.to_s}-\u9999"
+        end
+
+        # Deletes any non-current design docs that were created by this class. 
+        # Running this when you're deployed version of your application is steadily 
+        # and consistently using the latest code, is the way to clear out old design 
+        # docs. Running it to early could mean that live code has to regenerate
+        # potentially large indexes.
+        def cleanup_design_docs!
+          ddocs = all_design_doc_versions
+          ddocs["rows"].each do |row|
+            if (row['id'] != design_doc_id)
+              database.delete_doc({
+                "_id" => row['id'],
+                "_rev" => row['value']['rev']
+              })
+            end
+          end
+        end
+
+        private
+
+        def fetch_view_with_docs name, opts, raw=false, &block
+          if raw
+            fetch_view name, opts, &block
+          else
+            begin
+              view = fetch_view name, opts.merge({:include_docs => true}), &block
+              view['rows'].collect{|r|new(r['doc'])} if view['rows']
+            rescue
+              # fallback for old versions of couchdb that don't 
+              # have include_docs support
+              view = fetch_view name, opts, &block
+              view['rows'].collect{|r|new(database.get(r['id']))} if view['rows']
+            end
+          end
+        end
+
+        def fetch_view view_name, opts, &block
+          retryable = true
+          begin
+            design_doc.view(view_name, opts, &block)
+            # the design doc could have been deleted by a rouge process
+          rescue RestClient::ResourceNotFound => e
+            if retryable
+              refresh_design_doc
+              retryable = false
+              retry
+            else
+              raise e
+            end
+          end
+        end
+        
+      end # module ClassMethods
+      
+      
+    end
+  end
+end

data/lib/couchrest/mixins/properties.rb

@@ -0,0 +1,63 @@
+module CouchRest
+  module Mixins
+    module DocumentProperties
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        # Stores the class properties
+        def properties
+          @@properties ||= []
+        end
+
+        # This is not a thread safe operation, if you have to set new properties at runtime
+        # make sure to use a mutex.
+        def property(name, options={})
+          unless properties.map{|p| p.name}.include?(name.to_s)
+            property = CouchRest::Property.new(name, options.delete(:type), options)
+            create_property_getter(property) 
+            create_property_setter(property) unless property.read_only == true
+            properties << property 
+          end
+        end
+        
+        protected
+          # defines the getter for the property
+          def create_property_getter(property)
+            meth = property.name
+            class_eval <<-EOS
+              def #{meth}
+                self['#{meth}']
+              end
+            EOS
+
+            if property.alias
+              class_eval <<-EOS
+                alias #{property.alias.to_sym} #{meth.to_sym}
+              EOS
+            end
+          end
+
+          # defines the setter for the property
+          def create_property_setter(property)
+            meth = property.name
+            class_eval <<-EOS
+              def #{meth}=(value)
+                self['#{meth}'] = value
+              end
+            EOS
+
+            if property.alias
+              class_eval <<-EOS
+                alias #{property.alias.to_sym}= #{meth.to_sym}=
+              EOS
+            end
+          end
+          
+      end # module ClassMethods
+      
+    end
+  end
+end

data/lib/couchrest/mixins/views.rb

@@ -0,0 +1,59 @@
+module CouchRest
+  module Mixins
+    module Views
+    
+      # alias for self['_id']
+      def id
+        self['_id']
+      end
+
+      # alias for self['_rev']      
+      def rev
+        self['_rev']
+      end
+
+      # returns true if the document has never been saved
+      def new_document?
+        !rev
+      end
+    
+      # Saves the document to the db using create or update. Also runs the :save
+      # callbacks. Sets the <tt>_id</tt> and <tt>_rev</tt> fields based on
+      # CouchDB's response.
+      # If <tt>bulk</tt> is <tt>true</tt> (defaults to false) the document is cached for bulk save.
+      def save(bulk = false)
+        raise ArgumentError, "doc.database required for saving" unless database
+        result = database.save_doc self, bulk
+        result['ok']
+      end
+
+      # Deletes the document from the database. Runs the :delete callbacks.
+      # Removes the <tt>_id</tt> and <tt>_rev</tt> fields, preparing the
+      # document to be saved to a new <tt>_id</tt>.
+      # If <tt>bulk</tt> is <tt>true</tt> (defaults to false) the document won't 
+      # actually be deleted from the db until bulk save.
+      def destroy(bulk = false)
+        raise ArgumentError, "doc.database required to destroy" unless database
+        result = database.delete_doc(self, bulk)
+        if result['ok']
+          self['_rev'] = nil
+          self['_id'] = nil
+        end
+        result['ok']
+      end
+    
+      def copy(dest)
+        raise ArgumentError, "doc.database required to copy" unless database
+        result = database.copy_doc(self, dest)
+        result['ok']
+      end
+    
+      def move(dest)
+        raise ArgumentError, "doc.database required to copy" unless database
+        result = database.move_doc(self, dest)
+        result['ok']
+      end
+    
+    end
+  end
+end

data/lib/couchrest/more/extended_document.rb

@@ -0,0 +1,114 @@
+require 'rubygems'
+begin
+  gem 'extlib'
+  require 'extlib'
+rescue 
+  puts "CouchRest::Model requires extlib. This is left out of the gemspec on purpose."
+  raise
+end
+require 'mime/types'
+require File.join(File.dirname(__FILE__), "property")
+require File.join(File.dirname(__FILE__), '..', 'mixins', 'extended_document_mixins')
+
+module CouchRest
+  
+  # Same as CouchRest::Document but with properties and validations
+  class ExtendedDocument < Document
+    include CouchRest::Mixins::DocumentQueries
+    include CouchRest::Mixins::DocumentProperties
+    include CouchRest::Mixins::ExtendedViews
+    include CouchRest::Mixins::DesignDoc
+
+    
+    # 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!
+      before(:save) do
+        self['updated_at'] = Time.now
+        self['created_at'] = self['updated_at'] if new_document?
+      end
+    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
+    
+    ### instance methods
+    
+    # Returns the Class properties
+    #
+    # ==== Returns
+    # Array:: the list of properties for the instance
+    def properties
+      self.class.properties
+    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)
+      hash.each do |k, v|
+        raise NoMethodError, "#{k}= method not available, use key_accessor or key_writer :#{k}" unless self.respond_to?("#{k}=")
+      end      
+      hash.each do |k, v|
+        self.send("#{k}=",v)
+      end
+    end
+
+    # 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_document?
+    
+    # Overridden to set the unique ID.
+    # Returns a boolean value
+    def save(bulk = false)
+      set_unique_id if new_document? && self.respond_to?(:set_unique_id)
+      result = database.save_doc(self, bulk)
+      result["ok"] == true
+    end
+    
+    # Saves the document to the db using create or update. Raises an exception
+    # if the document is not saved properly.
+    def save!
+      raise "#{self.inspect} failed to save" unless self.save
+    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
+      result = database.delete_doc self
+      if result['ok']
+        self['_rev'] = nil
+        self['_id'] = nil
+      end
+      result['ok']
+    end
+      
+  end
+end

data/lib/couchrest/more/property.rb

@@ -0,0 +1,26 @@
+module CouchRest
+  
+  # Basic attribute support adding getter/setter + validation
+  class Property
+    attr_reader :name, :type, :validation_format, :required, :read_only, :alias
+    
+    # attribute to define
+    def initialize(name, type = String, options = {})
+      @name      = name.to_s
+      @type      = type
+      parse_options(options)
+      self
+    end
+    
+    
+    private
+      def parse_options(options)
+        return if options.empty?
+        @required           = true if (options[:required] && (options[:required] == true))
+        @validation_format  = options[:format] if options[:format]
+        @read_only          = options[:read_only] if options[:read_only]
+        @alias              = options[:alias]     if options
+      end
+    
+  end
+end

data/spec/couchrest/core/database_spec.rb

@@ -101,6 +101,10 @@ describe CouchRest::Database do
       rs = @db.view('first/test')
       rs['rows'].select{|r|r['key'] == 'wild' && r['value'] == 'and random'}.length.should == 1
     end
+    it "should return the raw result" do
+      rs = @db.view('first/test', :raw => true)
+      rs.should be_kind_of(String)
+    end
     it "should work with a range" do
       rs = @db.view('first/test', :startkey => "b", :endkey => "z")
       rs['rows'].length.should == 2
@@ -117,6 +121,14 @@ describe CouchRest::Database do
       rs = @db.view('first/test', :keys => ["another", "wild"])
       rs['rows'].length.should == 2
     end
+    it "should work with multi-keys in raw mode" do
+      rs = @db.view('first/test', :keys => ["another", "wild"], :raw => true)
+      rs.should be_kind_of(String)
+    end
+    it "should work with stripes" do
+      rs = @db.view('first/test', :stripes => [{:startkey => "another", :endkey => "anothes"}, {:startkey => "wild", :endkey => "wile"}])
+      rs['rows'].length.should == 2
+    end
     it "should accept a block" do
       rows = []
       rs = @db.view('first/test', :include_docs => true) do |row|

data/spec/couchrest/core/server_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe CouchRest::Server do
+  
+  before(:all) do
+    @couch = CouchRest::Server.new
+  end
+  
+  after(:all) do
+    @couch.available_databases.each do |ref, db|
+      db.delete!
+    end
+  end
+  
+  describe "available databases" do
+    it "should let you add more databases" do
+      @couch.available_databases.should be_empty
+      @couch.define_available_database(:default, "cr-server-test-db")
+      @couch.available_databases.keys.should include(:default)
+    end
+    
+    it "should verify that a database is available" do
+      @couch.available_database?(:default).should be_true
+      @couch.available_database?("cr-server-test-db").should be_true
+      @couch.available_database?(:matt).should be_false
+    end
+    
+    it "should let you set a default database" do
+      @couch.default_database = 'cr-server-test-default-db'
+      @couch.available_database?(:default).should be_true
+    end
+  end
+  
+end

data/spec/couchrest/more/property_spec.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+# check the following file to see how to use the spec'd features.
+require File.join(FIXTURE_PATH, 'more', 'card')
+
+describe "ExtendedDocument properties" do
+  
+  before(:each) do
+    @card = Card.new(:first_name => "matt")
+  end
+  
+  it "should be accessible from the object" do
+    @card.properties.should be_an_instance_of(Array)
+    @card.properties.map{|p| p.name}.should include("first_name")
+  end
+  
+  it "should let you access a property value (getter)" do
+    @card.first_name.should == "matt"
+  end
+  
+  it "should let you set a property value (setter)" do
+    @card.last_name = "Aimonetti"
+    @card.last_name.should == "Aimonetti"
+  end
+  
+  it "should not let you set a property value if it's read only" do
+    lambda{@card.read_only_value = "test"}.should raise_error
+  end
+  
+  it "should let you use an alias for an attribute" do
+    @card.last_name = "Aimonetti"
+    @card.family_name.should == "Aimonetti"
+    @card.family_name.should == @card.last_name
+  end
+  
+end

data/spec/fixtures/more/card.rb

@@ -0,0 +1,7 @@
+class Card < CouchRest::ExtendedDocument  
+  use_database TEST_SERVER.default_database
+  property :first_name
+  property :last_name,        :alias     => :family_name
+  property :read_only_value,  :read_only => true
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: derfred-couchrest
 version: !ruby/object:Gem::Version 
-  version: 0.12.6
+  version: 0.12.6.3
 platform: ruby
 authors: 
 - J. Chris Anderson
@@ -14,6 +14,7 @@ default_executable:
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -23,6 +24,7 @@ dependencies:
     version: 
 - !ruby/object:Gem::Dependency 
   name: rest-client
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -32,6 +34,7 @@ dependencies:
     version: 
 - !ruby/object:Gem::Dependency 
   name: mime-types
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -83,9 +86,21 @@ files:
 - lib/couchrest/core/server.rb
 - lib/couchrest/core/view.rb
 - lib/couchrest/helper
+- lib/couchrest/helper/file_manager.rb
 - lib/couchrest/helper/pager.rb
 - lib/couchrest/helper/streamer.rb
+- lib/couchrest/mixins
+- lib/couchrest/mixins/design_doc.rb
+- lib/couchrest/mixins/document_queries.rb
+- lib/couchrest/mixins/extended_document_mixins.rb
+- lib/couchrest/mixins/extended_views.rb
+- lib/couchrest/mixins/properties.rb
+- lib/couchrest/mixins/views.rb
+- lib/couchrest/mixins.rb
 - lib/couchrest/monkeypatches.rb
+- lib/couchrest/more
+- lib/couchrest/more/extended_document.rb
+- lib/couchrest/more/property.rb
 - lib/couchrest.rb
 - spec/couchrest
 - spec/couchrest/core
@@ -94,14 +109,19 @@ files:
 - spec/couchrest/core/design_spec.rb
 - spec/couchrest/core/document_spec.rb
 - spec/couchrest/core/model_spec.rb
+- spec/couchrest/core/server_spec.rb
 - spec/couchrest/helpers
 - spec/couchrest/helpers/pager_spec.rb
 - spec/couchrest/helpers/streamer_spec.rb
+- spec/couchrest/more
+- spec/couchrest/more/property_spec.rb
 - spec/fixtures
 - spec/fixtures/attachments
 - spec/fixtures/attachments/couchdb.png
 - spec/fixtures/attachments/README
 - spec/fixtures/attachments/test.html
+- spec/fixtures/more
+- spec/fixtures/more/card.rb
 - spec/fixtures/views
 - spec/fixtures/views/lib.js
 - spec/fixtures/views/test_view