jchris-couchrest 0.9.8 → 0.9.9

data/README.rdoc

@@ -48,4 +48,9 @@ Creating and Querying Views:
       })
     puts @db.view('first/test')['rows'].inspect 
 
+== CouchRest::Model
 
+CouchRest::Model is a module designed along the lines of DataMapper::Resource. By 
+including it in your class, suddenly you get all sorts of magic sugar, so that
+working with CouchDB in your Rails or Merb app is no harder than working with the
+standard SQL alternatives. See the CouchRest::Model documentation for and example article class that illustrates usage.

data/Rakefile

@@ -5,7 +5,7 @@ require 'spec/rake/spectask'
 
 spec = Gem::Specification.new do |s|
   s.name = "couchrest"
-  s.version = "0.9.8"
+  s.version = "0.9.9"
   s.date = "2008-09-11"
   s.summary = "Lean and RESTful interface to CouchDB."
   s.email = "jchris@grabb.it"
@@ -22,42 +22,41 @@ spec = Gem::Specification.new do |s|
   s.executables << 'couchapp'
   s.add_dependency("json", ">= 1.1.2")
   s.add_dependency("rest-client", ">= 0.5")
+  s.add_dependency("extlib", ">= 0.9.6")
 end
 
-namespace :github do # thanks merb!
-  desc "Update Github Gemspec"
-  task :update_gemspec do
-    skip_fields = %w(new_platform original_platform)
-    integer_fields = %w(specification_version)
+desc "Update Github Gemspec"
+task :gemspec do
+  skip_fields = %w(new_platform original_platform)
+  integer_fields = %w(specification_version)
 
-    result = "Gem::Specification.new do |s|\n"
-    spec.instance_variables.each do |ivar|
-      value = spec.instance_variable_get(ivar)
-      name  = ivar.split("@").last
-      next if skip_fields.include?(name) || value.nil? || value == "" || (value.respond_to?(:empty?) && value.empty?)
-      if name == "dependencies"
-        value.each do |d|
-          dep, *ver = d.to_s.split(" ")
-          result <<  "  s.add_dependency #{dep.inspect}, [#{ /\(([^\,]*)/ . match(ver.join(" "))[1].inspect}]\n"
-        end
-      else        
-        case value
-        when Array
-          value =  name != "files" ? value.inspect : value.inspect.split(",").join(",\n")
-        when Fixnum
-          # leave as-is
-        when String
-          value = value.to_i if integer_fields.include?(name)
-          value = value.inspect
-        else
-          value = value.to_s.inspect
-        end
-        result << "  s.#{name} = #{value}\n"
+  result = "Gem::Specification.new do |s|\n"
+  spec.instance_variables.each do |ivar|
+    value = spec.instance_variable_get(ivar)
+    name  = ivar.split("@").last
+    next if skip_fields.include?(name) || value.nil? || value == "" || (value.respond_to?(:empty?) && value.empty?)
+    if name == "dependencies"
+      value.each do |d|
+        dep, *ver = d.to_s.split(" ")
+        result <<  "  s.add_dependency #{dep.inspect}, [#{ /\(([^\,]*)/ . match(ver.join(" "))[1].inspect}]\n"
       end
+    else        
+      case value
+      when Array
+        value =  name != "files" ? value.inspect : value.inspect.split(",").join(",\n")
+      when Fixnum
+        # leave as-is
+      when String
+        value = value.to_i if integer_fields.include?(name)
+        value = value.inspect
+      else
+        value = value.to_s.inspect
+      end
+      result << "  s.#{name} = #{value}\n"
     end
-    result << "end"
-    File.open(File.join(File.dirname(__FILE__), "#{spec.name}.gemspec"), "w"){|f| f << result}
   end
+  result << "end"
+  File.open(File.join(File.dirname(__FILE__), "#{spec.name}.gemspec"), "w"){|f| f << result}
 end
 
 desc "Run all specs"
@@ -67,7 +66,7 @@ end
 
 desc "Print specdocs"
 Spec::Rake::SpecTask.new(:doc) do |t|
-	t.spec_opts = ["--format", "specdoc", "--dry-run"]
+	t.spec_opts = ["--format", "specdoc"]
 	t.spec_files = FileList['spec/*_spec.rb']
 end
 
@@ -80,8 +79,4 @@ Rake::RDocTask.new do |rdoc|
 end
 
 desc "Generate the gemspec"
-
-
-
-
 task :default => :spec

data/lib/couchrest/core/database.rb

@@ -5,6 +5,12 @@ module CouchRest
   class Database
     attr_reader :server, :host, :name, :root
      
+    # Create a CouchRest::Database adapter for the supplied CouchRest::Server and database name.
+    # 
+    # ==== Parameters
+    # server<CouchRest::Server>:: database host
+    # name<String>:: database name
+    #
     def initialize server, name
       @name = name
       @server = server
@@ -12,52 +18,48 @@ module CouchRest
       @root = "#{host}/#{name}"
     end
     
+    # returns the database's uri
     def to_s
       @root
     end
     
+    # GET the database info from CouchDB
     def info
       CouchRest.get @root
     end
     
+    # Query the <tt>_all_docs</tt> view. Accepts all the same arguments as view.
     def documents params = nil
       url = CouchRest.paramify_url "#{@root}/_all_docs", params
       CouchRest.get url  
     end
   
+    # POST a temporary view function to CouchDB for querying. This is not recommended, as you don't get any performance benefit from CouchDB's materialized views. Can be quite slow on large databases.
     def temp_view funcs, params = nil
       url = CouchRest.paramify_url "#{@root}/_temp_view", params
       JSON.parse(RestClient.post(url, funcs.to_json, {"Content-Type" => 'application/json'}))
     end
   
+    # Query a CouchDB view as defined by a <tt>_design</tt> document. Accepts paramaters as described in http://wiki.apache.org/couchdb/HttpViewApi
     def view name, params = nil
       url = CouchRest.paramify_url "#{@root}/_view/#{name}", params
       CouchRest.get url
     end
-
-    # experimental
-    def search params = nil
-      url = CouchRest.paramify_url "#{@root}/_search", params
-      CouchRest.get url
-    end
-    # experimental
-    def action action, params = nil
-      url = CouchRest.paramify_url "#{@root}/_action/#{action}", params
-      CouchRest.get url
-    end
     
+    # GET a document from CouchDB, by id. Returns a Ruby Hash.
     def get id
       slug = CGI.escape(id) 
       CouchRest.get "#{@root}/#{slug}"
     end
     
+    # GET an attachment directly from CouchDB
     def fetch_attachment doc, name
       doc = CGI.escape(doc)
       name = CGI.escape(name)
       RestClient.get "#{@root}/#{doc}/#{name}"
     end
     
-    # PUT or POST depending on presence of _id attribute
+    # Save a document to CouchDB. This will use the <tt>_id</tt> field from the document as the id for PUT, or request a new UUID from CouchDB, if no <tt>_id</tt> is present on the document. IDs are attached to documents on the client side because POST has the curious property of being automatically retried by proxies in the event of network segmentation and lost responses.
     def save doc
       if doc['_attachments']
         doc['_attachments'] = encode_attachments(doc['_attachments'])
@@ -75,6 +77,7 @@ module CouchRest
       end
     end
     
+    # POST an array of documents to CouchDB. If any of the documents are missing ids, supply one from the uuid cache.
     def bulk_save docs
       ids, noids = docs.partition{|d|d['_id']}
       uuid_count = [noids.length, @server.uuid_batch_count].max
@@ -85,11 +88,13 @@ module CouchRest
       CouchRest.post "#{@root}/_bulk_docs", {:docs => docs}
     end
     
+    # DELETE the document from CouchDB that has the given <tt>_id</tt> and <tt>_rev</tt>.
     def delete doc
       slug = CGI.escape(doc['_id'])
       CouchRest.delete "#{@root}/#{slug}?rev=#{doc['_rev']}"
     end
     
+    # DELETE the database itself. This is not undoable and could be rather catastrophic. Use with care!
     def delete!
       CouchRest.delete @root
     end

data/lib/couchrest/core/model.rb

@@ -0,0 +1,352 @@
+# = CouchRest::Model - ORM, the CouchDB way
+module CouchRest
+  # = CouchRest::Model - ORM, the CouchDB way
+  # 
+  # CouchRest::Model provides an ORM-like interface for CouchDB documents. It avoids all usage of <tt>method_missing</tt>, and tries to strike a balance between usability and magic. See CouchRest::Model::MagicViews#view_by for documentation about the view-generation system. For the other class methods, inspiried by DataMapper and ActiveRecord, see CouchRest::Model::ClassMethods. The InstanceMethods are pretty basic.
+  # 
+  # ==== Example
+  # 
+  # This is an example class using CouchRest::Model. It is taken from the spec/couchrest/core/model_spec.rb file, which may be even more up to date than this example.
+  # 
+  #   class Article
+  #     include CouchRest::Model
+  #     use_database CouchRest.database!('http://localhost:5984/couchrest-model-test')
+  #     unique_id :slug
+  #
+  #     view_by :date, :descending => true
+  #     view_by :user_id, :date
+  #
+  #     view_by :tags,
+  #       :map => 
+  #         "function(doc) {
+  #           if (doc.type == 'Article' && doc.tags) {
+  #             doc.tags.forEach(function(tag){
+  #               emit(tag, 1);
+  #             });
+  #           }
+  #         }",
+  #       :reduce => 
+  #         "function(keys, values, rereduce) {
+  #           return sum(values);
+  #         }"  
+  #
+  #     key_writer :date
+  #     key_reader :slug, :created_at, :updated_at
+  #     key_accessor :title, :tags
+  #
+  #     timestamps!
+  #
+  #     before(:create, :generate_slug_from_title)  
+  #     def generate_slug_from_title
+  #       doc['slug'] = title.downcase.gsub(/[^a-z0-9]/,'-').squeeze('-').gsub(/^\-|\-$/,'')
+  #     end
+  #   end
+  module Model
+    class << self
+      # this is the CouchRest::Database that model classes will use unless they override it with <tt>use_database</tt>
+      attr_accessor :default_database
+    end
+    
+    # instance methods on the model classes
+    module InstanceMethods
+      attr_accessor :doc
+      
+      def initialize keys = {}
+        self.doc = {}
+        keys.each do |k,v|
+          doc[k.to_s] = v
+        end
+        unless doc['_id'] && doc['_rev']
+          init_doc
+        end
+      end
+      
+      # returns the database used by this model's class
+      def database
+        self.class.database
+      end
+      
+      # alias for doc['_id']
+      def id
+        doc['_id']
+      end
+
+      # alias for doc['_rev']      
+      def rev
+        doc['_rev']
+      end
+      
+      # returns true if the doc has never been saved
+      def new_record?
+        !doc['_rev']
+      end
+      
+      # save the doc to the db using create or update
+      def save
+        if new_record?
+          create
+        else
+          update
+        end
+      end
+
+      protected
+      
+      def create
+        set_unique_id if respond_to?(:set_unique_id) # hack
+        save_doc
+      end
+      
+      def update
+        save_doc
+      end
+      
+      private
+      
+      def save_doc
+        result = database.save doc
+        if result['ok']
+          doc['_id'] = result['id']
+          doc['_rev'] = result['rev']
+        end
+        result['ok']
+      end
+      
+      def init_doc
+        doc['type'] = self.class.to_s
+      end
+    end # module InstanceMethods
+    
+    # Class methods for models that include CouchRest::Model
+    module ClassMethods
+      # override the CouchRest::Model-wide default_database
+      def use_database db
+        @database = db
+      end
+      
+      # returns the CouchRest::Database instance that this class uses
+      def database
+        @database || CouchRest::Model.default_database
+      end
+      
+      # load a document from the database
+      def get id
+        doc = database.get id
+        new(doc)
+      end
+      
+      # Defines methods for reading and writing from fields in the document. Uses key_writer and key_reader internally.
+      def key_accessor *keys
+        key_writer *keys
+        key_reader *keys
+      end
+      
+      # For each argument key, define a method <tt>key=</tt> that sets the corresponding field on the CouchDB document.
+      def key_writer *keys
+        keys.each do |method|
+          key = method.to_s
+          define_method "#{method}=" do |value|
+            doc[key] = value
+          end
+        end
+      end
+
+      # For each argument key, define a method <tt>key</tt> that reads the corresponding field on the CouchDB document.      
+      def key_reader *keys
+        keys.each do |method|
+          key = method.to_s
+          define_method method do
+            doc[key]
+          end
+        end
+      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 timestamps!
+        before(:create) do
+          doc['updated_at'] = doc['created_at'] = Time.now
+        end                  
+        before(:update) do   
+          doc['updated_at'] = Time.now
+        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 unique_id method
+        define_method :set_unique_id do
+          doc['_id'] ||= self.send(method)
+        end
+      end
+      
+    end # module ClassMethods
+
+    module MagicViews
+      
+      # 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.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.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.rb</tt>.
+      def view_by *keys
+        opts = keys.pop if keys.last.is_a?(Hash)
+        opts ||= {}
+        type = self.to_s
+
+        method_name = "by_#{keys.join('_and_')}"
+        @@design_doc ||= default_design_doc
+        
+        if opts[:map]
+          view = {}
+          view['map'] = opts.delete(:map)
+          if opts[:reduce]
+            view['reduce'] = opts.delete(:reduce)
+            opts[:reduce] = false
+          end
+          @@design_doc['views'][method_name] = view
+        else
+          doc_keys = keys.collect{|k|"doc['#{k}']"}
+          key_protection = doc_keys.join(' && ')
+          key_emit = doc_keys.length == 1 ? "#{doc_keys.first}" : "[#{doc_keys.join(', ')}]"
+          map_function = <<-JAVASCRIPT
+          function(doc) {
+            if (doc.type == '#{type}' && #{key_protection}) {
+              emit(#{key_emit}, null);
+            }
+          }
+          JAVASCRIPT
+          @@design_doc['views'][method_name] = {
+            'map' => map_function
+          }
+        end
+        
+        @@design_doc_fresh = false
+        
+        self.meta_class.instance_eval do
+          define_method method_name do |*args|
+            query = opts.merge(args[0] || {})
+            query[:raw] = true if query[:reduce]
+            unless @@design_doc_fresh
+              refresh_design_doc
+            end
+            raw = query.delete(:raw)
+            view_name = "#{type}/#{method_name}"
+
+            view = fetch_view(view_name, query)
+            if raw
+              view
+            else
+              # TODO this can be optimized once the include-docs patch is applied
+              view['rows'].collect{|r|new(database.get(r['id']))}
+            end
+          end
+        end
+      end
+      
+      private
+      
+      def fetch_view view_name, opts
+        retryable = true
+        begin
+          database.view(view_name, opts)
+        # 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
+      
+      def design_doc_id
+        "_design/#{self.to_s}"
+      end
+      
+      def default_design_doc
+        {
+          "_id" => design_doc_id,
+          "language" => "javascript",
+          "views" => {}
+        }
+      end
+      
+      def refresh_design_doc
+        saved = database.get(design_doc_id) rescue nil
+        if saved
+          @@design_doc['views'].each do |name, view|
+            saved['views'][name] = view
+          end
+          database.save(saved)
+        else
+          database.save(@@design_doc)
+        end
+        @@design_doc_fresh = true
+      end
+      
+    end # module MagicViews
+    
+    module Callbacks
+      def self.included(model)
+        model.class_eval <<-EOS, __FILE__, __LINE__
+          include Extlib::Hook
+          register_instance_hooks :save, :create, :update #, :destroy
+        EOS
+      end
+    end # module Callbacks
+    
+    # bookkeeping section
+    
+    # load the code into the model class
+    def self.included(model)
+      model.send(:include, InstanceMethods)
+      model.extend ClassMethods
+      model.extend MagicViews
+      model.send(:include, Callbacks)
+    end
+    
+  end # module Model
+end # module CouchRest

data/lib/couchrest/core/server.rb

@@ -6,37 +6,39 @@ module CouchRest
       @uuid_batch_count = uuid_batch_count
     end
   
-    # list all databases on the server
+    # List all databases on the server
     def databases
       CouchRest.get "#{@uri}/_all_dbs"
     end
   
+    # Returns a CouchRest::Database for the given name
     def database name
       CouchRest::Database.new(self, name)
     end
   
-    # creates the database if it doesn't exist
+    # Creates the database if it doesn't exist
     def database! name
       create_db(name) rescue nil
       database name
     end
   
-    # get the welcome message
+    # GET the welcome message
     def info
       CouchRest.get "#{@uri}/"
     end
 
-    # create a database
+    # Create a database
     def create_db name
       CouchRest.put "#{@uri}/#{name}"
       database name
     end
 
-    # restart the couchdb instance
+    # Restart the CouchDB instance
     def restart!
       CouchRest.post "#{@uri}/_restart"
     end
 
+    # Retrive an unused UUID from CouchDB. Server instances manage caching a list of unused UUIDs.
     def next_uuid count = @uuid_batch_count
       @uuids ||= []
       if @uuids.empty?

data/lib/couchrest/helper/streamer.rb

@@ -5,6 +5,7 @@ module CouchRest
       @db = db
     end
     
+    # Stream a view, yielding one row at a time. Shells out to <tt>curl</tt> to keep RAM usage low when you have millions of rows.
     def view name, params = nil
       urlst = /^_/.match(name) ? "#{@db.root}/#{name}" : "#{@db.root}/_view/#{name}"
       url = CouchRest.paramify_url urlst, params

data/lib/couchrest/monkeypatches.rb

@@ -1,18 +1,20 @@
-
-# this file must be loaded after the JSON gem
-
+# This file must be loaded after the JSON gem and any other library that beats up the Time class.
 class Time
-  # this date format sorts lexicographically
-  # and is compatible with Javascript's new Date(time_string) constructor
-  # note that sorting will break if you store times from multiple timezones
-  # I like to add a ENV['TZ'] = 'UTC' to my apps
+  # This date format sorts lexicographically
+  # and is compatible with Javascript's <tt>new Date(time_string)</tt> constructor.
+  # Note this this format stores all dates in UTC so that collation 
+  # order is preserved. (There's no longer a need to set <tt>ENV['TZ'] = 'UTC'</tt>
+  # in your application.)
 
   def to_json(options = nil)
-    %("#{strftime("%Y/%m/%d %H:%M:%S %z")}")
+    u = self.utc
+    %("#{u.strftime("%Y/%m/%d %H:%M:%S +0000")}")
   end
 
-  # this works to decode the outputted time format
-  # copied from ActiveSupport
+  # Decodes the JSON time format to a UTC time.
+  # Based on Time.parse from ActiveSupport. ActiveSupport's version
+  # is more complete, returning a time in your current timezone, 
+  # rather than keeping the time in UTC. YMMV.
   # def self.parse string, fallback=nil
   #   d = DateTime.parse(string).new_offset
   #   self.utc(d.year, d.month, d.day, d.hour, d.min, d.sec)

data/lib/couchrest.rb

@@ -15,6 +15,7 @@
 require "rubygems"
 require 'json'
 require 'rest_client'
+require 'extlib'
 
 $:.unshift File.dirname(__FILE__) unless
   $:.include?(File.dirname(__FILE__)) ||
@@ -23,9 +24,11 @@ $:.unshift File.dirname(__FILE__) unless
   
 require 'couchrest/monkeypatches'
 
+# = CouchDB, close to the metal
 module CouchRest
   autoload :Server,       'couchrest/core/server'
   autoload :Database,     'couchrest/core/database'
+  autoload :Model,        'couchrest/core/model'
   autoload :Pager,        'couchrest/helper/pager'
   autoload :FileManager,  'couchrest/helper/file_manager'
   autoload :Streamer,     'couchrest/helper/streamer'
@@ -76,19 +79,15 @@ module CouchRest
     # creates it if it isn't already there
     # returns it after it's been created
     def database! url
-      uri = URI.parse url
-      path = uri.path
-      uri.path = ''
-      cr = CouchRest.new(uri.to_s)
-      cr.database!(path)
+      parsed = parse url
+      cr = CouchRest.new(parsed[:host])
+      cr.database!(parsed[:database])
     end
   
     def database url
-      uri = URI.parse url
-      path = uri.path
-      uri.path = ''
-      cr = CouchRest.new(uri.to_s)
-      cr.database(path)
+      parsed = parse url
+      cr = CouchRest.new(parsed[:host])
+      cr.database(parsed[:database])
     end
     
     def put uri, doc = nil

data/spec/couchrest/core/model_spec.rb

@@ -0,0 +1,292 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+class Basic
+  include CouchRest::Model
+end
+
+class Article
+  include CouchRest::Model
+  use_database CouchRest.database!('http://localhost:5984/couchrest-model-test')
+  unique_id :slug
+  
+  view_by :date, :descending => true
+  view_by :user_id, :date
+  
+  view_by :tags,
+    :map => 
+      "function(doc) {
+        if (doc.type == 'Article' && doc.tags) {
+          doc.tags.forEach(function(tag){
+            emit(tag, 1);
+          });
+        }
+      }",
+    :reduce => 
+      "function(keys, values, rereduce) {
+        return sum(values);
+      }"  
+
+  key_writer :date
+  key_reader :slug, :created_at, :updated_at
+  key_accessor :title, :tags
+
+  timestamps!
+  
+  before(:create, :generate_slug_from_title)  
+  def generate_slug_from_title
+    doc['slug'] = title.downcase.gsub(/[^a-z0-9]/,'-').squeeze('-').gsub(/^\-|\-$/,'')
+  end
+end
+
+describe CouchRest::Model do
+  before(:all) do
+    @cr = CouchRest.new(COUCHHOST)
+    @db = @cr.database(TESTDB)
+    @db.delete! rescue nil
+    @db = @cr.create_db(TESTDB) rescue nil
+    @adb = @cr.database('couchrest-model-test')
+    @adb.delete! rescue nil
+    CouchRest.database!('http://localhost:5984/couchrest-model-test')
+    CouchRest::Model.default_database = CouchRest.database!('http://localhost:5984/couchrest-test')
+  end
+  
+  it "should use the default database" do
+    Basic.database.info['db_name'].should == 'couchrest-test'
+  end
+  
+  it "should override the default db" do
+    Article.database.info['db_name'].should == 'couchrest-model-test'
+  end
+  
+  describe "a new model" do
+    it "should be a new_record" do
+      @obj = Basic.new
+      @obj.should be_a_new_record
+    end
+  end
+  
+  describe "a model with key_accessors" do
+    it "should allow reading keys" do
+      @art = Article.new
+      @art.doc['title'] = 'My Article Title'
+      @art.title.should == 'My Article Title'
+    end
+    it "should allow setting keys" do
+      @art = Article.new
+      @art.title = 'My Article Title'
+      @art.doc['title'].should == 'My Article Title'
+    end
+  end
+  
+  describe "a model with key_writers" do
+    it "should allow setting keys" do
+      @art = Article.new
+      t = Time.now
+      @art.date = t
+      @art.doc['date'].should == t
+    end
+    it "should not allow reading keys" do
+      @art = Article.new
+      t = Time.now
+      @art.date = t
+      lambda{@art.date}.should raise_error
+    end
+  end
+  
+  describe "a model with key_readers" do
+    it "should allow reading keys" do
+      @art = Article.new
+      @art.doc['slug'] = 'my-slug'
+      @art.slug.should == 'my-slug'
+    end
+    it "should not allow setting keys" do
+      @art = Article.new
+      lambda{@art.slug = 'My Article Title'}.should raise_error
+    end
+  end
+  
+  describe "getting a model" do
+    before(:all) do
+      @art = Article.new(:title => 'All About Getting')
+      @art.save
+    end
+    it "should load and instantiate it" do
+      foundart = Article.get @art.id
+      foundart.title.should == "All About Getting"
+    end
+  end
+
+  describe "saving a model" do
+    before(:all) do
+      @obj = Basic.new
+      @obj.save.should == true
+    end
+    
+    it "should save the doc" do
+      doc = @obj.database.get @obj.id
+      doc['_id'].should == @obj.id
+    end
+    
+    it "should be set for resaving" do
+      rev = @obj.rev
+      @obj.doc['another-key'] = "some value"
+      @obj.save
+      @obj.rev.should_not == rev
+    end
+    
+    it "should set the id" do
+      @obj.id.should be_an_instance_of String
+    end
+    
+    it "should set the type" do
+      @obj.doc['type'].should == 'Basic'
+    end
+  end
+
+  describe "saving a model with a unique_id configured" do
+    before(:each) do
+      @art = Article.new
+      @old = Article.database.get('this-is-the-title') rescue nil
+      Article.database.delete(@old) if @old
+    end
+    
+    it "should require the title" do
+      lambda{@art.save}.should raise_error
+      @art.title = 'This is the title'
+      @art.save.should == true
+    end
+    
+    it "should not change the slug on update" do
+      @art.title = 'This is the title'
+      @art.save.should == true
+      @art.title = 'new title'
+      @art.save.should == true
+      @art.slug.should == 'this-is-the-title'
+    end
+    
+    it "should raise an error when the slug is taken" do
+      @art.title = 'This is the title'
+      @art.save.should == true
+      @art2 = Article.new(:title => 'This is the title!')
+      lambda{@art2.save}.should raise_error
+    end
+    
+    it "should set the slug" do
+      @art.title = 'This is the title'
+      @art.save.should == true
+      @art.slug.should == 'this-is-the-title'
+    end
+    
+    it "should set the id" do
+      @art.title = 'This is the title'
+      @art.save.should == true
+      @art.id.should == 'this-is-the-title'
+    end
+  end
+
+  describe "a model with timestamps" do
+    before(:all) do
+      @art = Article.new(:title => "Saving this")
+      @art.save
+    end
+    it "should set the time on create" do
+      (Time.now - @art.created_at).should < 2
+      foundart = Article.get @art.id
+      foundart.created_at.should == foundart.updated_at
+    end
+    it "should set the time on update" do
+      @art.save
+      @art.created_at.should < @art.updated_at
+    end
+  end
+
+  describe "a model with simple views and a default param" do
+    before(:all) do
+      written_at = Time.now - 24 * 3600 * 7
+      @titles = ["this and that", "also interesting", "more fun", "some junk"]
+      @titles.each do |title|
+        a = Article.new(:title => title)
+        a.date = written_at
+        a.save
+        written_at += 24 * 3600
+      end
+    end
+    
+    it "should create the design doc" do
+      Article.by_date rescue nil
+      doc = Article.database.get("_design/Article")
+      doc['views']['by_date'].should_not be_nil
+    end
+    
+    it "should return the matching raw view result" do
+      view = Article.by_date :raw => true
+      view['rows'].length.should == 4
+    end
+    
+    it "should return the matching objects (with descending)" do
+      articles = Article.by_date
+      articles.collect{|a|a.title}.should == @titles.reverse
+    end
+    
+    it "should allow you to override default args" do
+      articles = Article.by_date :descending => false
+      articles.collect{|a|a.title}.should == @titles
+    end
+  end
+  
+  describe "a model with a compound key view" do
+    before(:all) do
+      written_at = Time.now - 24 * 3600 * 7
+      @titles = ["uniq one", "even more interesting", "less fun", "not junk"]
+      @user_ids = ["quentin", "aaron"]
+      @titles.each_with_index do |title,i|
+        u = i % 2
+        a = Article.new(:title => title, :user_id => @user_ids[u])
+        a.date = written_at
+        a.save
+        written_at += 24 * 3600
+      end
+    end
+    it "should create the design doc" do
+      Article.by_user_id_and_date rescue nil
+      doc = Article.database.get("_design/Article")
+      doc['views']['by_date'].should_not be_nil
+    end
+    it "should sort correctly" do
+      articles = Article.by_user_id_and_date
+      articles.collect{|a|a.doc['user_id']}.should == ['aaron', 'aaron', 'quentin', 'quentin']
+      articles[1].title.should == 'not junk'
+    end
+    it "should be queryable with couchrest options" do
+      articles = Article.by_user_id_and_date :count => 1, :startkey => 'quentin'
+      articles.length.should == 1
+      articles[0].title.should == "even more interesting"
+    end
+  end
+  
+  describe "with a custom view" do
+    before(:all) do
+      @titles = ["very uniq one", "even less interesting", "some fun", "really junk", "crazy bob"]
+      @tags = ["cool", "lame"]
+      @titles.each_with_index do |title,i|
+        u = i % 2
+        a = Article.new(:title => title, :tags => [@tags[u]])
+        a.save
+      end
+    end
+    it "should be available raw" do
+      view = Article.by_tags :raw => true
+      view['rows'].length.should == 5
+    end
+
+    it "should be default to :reduce => false" do
+      ars = Article.by_tags
+      ars.first.tags.first.should == 'cool'
+    end
+    
+    it "should be raw when reduce is true" do
+      view = Article.by_tags :reduce => true, :group => true
+      view['rows'].find{|r|r['key'] == 'cool'}['value'].should == 3
+    end
+  end
+end

data/spec/couchrest_spec.rb

@@ -139,8 +139,13 @@ describe CouchRest do
     it "should be possible without an explicit CouchRest instantiation" do
       db = CouchRest.database "http://localhost:5984/couchrest-test"
       db.should be_an_instance_of(CouchRest::Database)
-      db.host.should == "http://localhost:5984"
+      db.host.should == "localhost:5984"
     end
+    # TODO add https support (need test environment...)
+    # it "should work with https" # do
+    #      db = CouchRest.database "https://localhost:5984/couchrest-test"
+    #      db.host.should == "https://localhost:5984"
+    #    end
     it "should not create the database automatically" do
       db = CouchRest.database "http://localhost:5984/couchrest-test"
       lambda{db.info}.should raise_error(RestClient::ResourceNotFound)      
@@ -150,6 +155,7 @@ describe CouchRest do
   describe "ensuring the db exists" do
     it "should be super easy" do
       db = CouchRest.database! "http://localhost:5984/couchrest-test-2"
+      db.name.should == 'couchrest-test-2'
       db.info["db_name"].should == 'couchrest-test-2'
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jchris-couchrest
 version: !ruby/object:Gem::Version 
-  version: 0.9.8
+  version: 0.9.9
 platform: ruby
 authors: 
 - J. Chris Anderson
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-10 21:00:00 -07:00
+date: 2008-09-11 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,6 +30,15 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0.5"
     version: 
+- !ruby/object:Gem::Dependency 
+  name: extlib
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.6
+    version: 
 description: CouchRest provides a simple interface on top of CouchDB's RESTful HTTP API, as well as including some utility scripts for managing views and attachments.
 email: jchris@grabb.it
 executables: 
@@ -70,6 +79,7 @@ files:
 - lib/couchrest/commands/push.rb
 - lib/couchrest/core
 - lib/couchrest/core/database.rb
+- lib/couchrest/core/model.rb
 - lib/couchrest/core/server.rb
 - lib/couchrest/helper
 - lib/couchrest/helper/file_manager.rb
@@ -82,6 +92,9 @@ files:
 - lib/couchrest/monkeypatches.rb
 - lib/couchrest.rb
 - spec/couchapp_spec.rb
+- spec/couchrest
+- spec/couchrest/core
+- spec/couchrest/core/model_spec.rb
 - spec/couchrest_spec.rb
 - spec/database_spec.rb
 - spec/file_manager_spec.rb
@@ -95,6 +108,12 @@ files:
 - spec/fixtures/couchapp/views/example-map.js
 - spec/fixtures/couchapp/views/example-reduce.js
 - spec/fixtures/couchapp-test
+- spec/fixtures/couchapp-test/my-app
+- spec/fixtures/couchapp-test/my-app/attachments
+- spec/fixtures/couchapp-test/my-app/attachments/index.html
+- spec/fixtures/couchapp-test/my-app/views
+- spec/fixtures/couchapp-test/my-app/views/example-map.js
+- spec/fixtures/couchapp-test/my-app/views/example-reduce.js
 - spec/fixtures/views
 - spec/fixtures/views/lib.js
 - spec/fixtures/views/test_view