jchris-couchrest 0.9.12 → 0.12.2

data/lib/couchrest/core/model.rb

@@ -1,10 +1,12 @@
 require 'rubygems'
 require 'extlib'
 require 'digest/md5'
+require File.dirname(__FILE__) + '/document'
+require 'mime/types'
 
-# = CouchRest::Model - ORM, the CouchDB way
+# = CouchRest::Model - Document modeling, the CouchDB way
 module CouchRest
-  # = CouchRest::Model - ORM, the CouchDB way
+  # = CouchRest::Model - Document modeling, 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
@@ -18,7 +20,7 @@ module CouchRest
   # than this example.
   #    
   #   class Article < CouchRest::Model
-  #     use_database CouchRest.database!('http://localhost:5984/couchrest-model-test')
+  #     use_database CouchRest.database!('http://127.0.0.1:5984/couchrest-model-test')
   #     unique_id :slug
   #
   #     view_by :date, :descending => true
@@ -61,22 +63,19 @@ module CouchRest
   # * The most recent 20 articles. Remember that the <tt>view_by :date</tt>
   #   has the default option <tt>:descending => true</tt>.
   #  
-  #     Article.by_date :count => 20
+  #     Article.by_date :limit => 20
   #  
   # * The raw CouchDB view reduce result for the custom <tt>:tags</tt> view.
   #   In this case we'll get a count of the number of articles tagged "ruby".
   #  
   #     Article.by_tags :key => "ruby", :reduce => true
   #  
-  class Model < Hash
+  class Model < Document
 
     # instantiates the hash by converting all the keys to strings.
     def initialize keys = {}
-      super()
+      super(keys)
       apply_defaults
-      keys.each do |k,v|
-        self[k.to_s] = v
-      end
       cast_keys
       unless self['_id'] && self['_rev']
         self['couchrest-type'] = self.class.to_s
@@ -90,7 +89,7 @@ module CouchRest
     class_inheritable_accessor :casts
     class_inheritable_accessor :default_obj
     class_inheritable_accessor :class_database
-    class_inheritable_accessor :generated_design_doc
+    class_inheritable_accessor :design_doc
     class_inheritable_accessor :design_doc_slug_cache
     class_inheritable_accessor :design_doc_fresh
 
@@ -112,23 +111,66 @@ module CouchRest
       end
 
       # Load all documents that have the "couchrest-type" field equal to the
-      # name of the current class. Take thes the standard set of
+      # name of the current class. Take the standard set of
       # CouchRest::Database#view options.
-      def all opts = {}
-        self.generated_design_doc ||= default_design_doc
+      def all opts = {}, &block
+        self.design_doc ||= Design.new(default_design_doc)
         unless design_doc_fresh
           refresh_design_doc
         end
-        view_name = "#{design_doc_slug}/all"
-        raw = opts.delete(:raw)
-        fetch_view_with_docs(view_name, opts, raw)
+        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
       
       # Cast a field as another class. The class must be happy to have the
-      # field's primitive type as the argument to it's constucture. Classes
+      # field's primitive type as the argument to it's constuctur. Classes
       # which inherit from CouchRest::Model are happy to act as sub-objects
       # for any fields that are stored in JSON as object (and therefore are
       # parsed from the JSON as Ruby Hashes).
+      # 
+      # Example:
+      #
+      #   class Post < CouchRest::Model
+      #
+      #     key_accessor :title, :body, :author
+      #
+      #     cast :author, :as => 'Author'
+      #
+      #   end
+      # 
+      #   post.author.class #=> Author
+      #
+      # Using the same example, if a Post should have many Comments, we 
+      # would declare it like this:
+      #
+      #   class Post < CouchRest::Model
+      #
+      #     key_accessor :title, :body, :author, comments
+      #
+      #     cast :author, :as => 'Author'
+      #     cast :comments, :as => ['Comment']
+      #
+      #   end
+      #
+      #   post.author.class #=> Author
+      #   post.comments.class #=> Array
+      #   post.comments.first #=> Comment
+      # 
       def cast field, opts = {}
         self.casts ||= {}
         self.casts[field.to_s] = opts
@@ -175,11 +217,9 @@ module CouchRest
       # on the document whenever saving occurs. CouchRest uses a pretty
       # decent time format by default. See Time#to_json
       def timestamps!
-        before(:create) do
-          self['updated_at'] = self['created_at'] = Time.now
-        end                  
-        before(:update) do   
+        before(:save) do
           self['updated_at'] = Time.now
+          self['created_at'] = self['updated_at'] if new_document?
         end
       end
 
@@ -266,62 +306,34 @@ module CouchRest
       # 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 ||= {}
-        type = self.to_s
-
-        method_name = "by_#{keys.join('_and_')}"
-        self.generated_design_doc ||= default_design_doc
         ducktype = opts.delete(:ducktype)
-        if opts[:map]
-          view = {}
-          view['map'] = opts.delete(:map)
-          if opts[:reduce]
-            view['reduce'] = opts.delete(:reduce)
-            opts[:reduce] = false
-          end
-          generated_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 (#{!ducktype ? "doc['couchrest-type'] == '#{type}' && " : ""}#{key_protection}) {
-              emit(#{key_emit}, null);
-            }
-          }
-          JAVASCRIPT
-          generated_design_doc['views'][method_name] = {
-            'map' => map_function
-          }
+        unless ducktype || opts[:map]
+          opts[:guards] ||= []
+          opts[:guards].push "(doc['couchrest-type'] == '#{self.to_s}')"
         end
-        generated_design_doc['views'][method_name]['couchrest-defaults'] = opts
+        keys.push opts
+        self.design_doc.view_by(*keys)
         self.design_doc_fresh = false
-        method_name
       end
 
       def method_missing m, *args
-        if opts = has_view?(m)
+        if has_view?(m)
           query = args.shift || {}
-          view(m, opts.merge(query), *args)
+          view(m, query, *args)
         else
           super
         end
       end
 
-      # returns true if the there is a view named this in the design doc
+      # returns stored defaults if the there is a view named this in the design doc
       def has_view?(view)
         view = view.to_s
-        if generated_design_doc['views'][view]
-          generated_design_doc['views'][view]["couchrest-defaults"]
-        end
-      end
-
-      # Fetch the generated design doc. Could raise an error if the generated views have not been queried yet.
-      def design_doc
-        database.get("_design/#{design_doc_slug}")
+        design_doc && design_doc['views'] && design_doc['views'][view]
       end
 
       # Dispatches to any named view.
@@ -331,8 +343,29 @@ module CouchRest
         end
         query[:raw] = true if query[:reduce]        
         raw = query.delete(:raw)
-        view_name = "#{design_doc_slug}/#{name}"
-        fetch_view_with_docs(view_name, query, raw, &block)
+        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({
+              "_id" => row['id'],
+              "_rev" => row['value']['rev']
+            })
+          end
+        end
       end
 
       private
@@ -356,7 +389,7 @@ module CouchRest
       def fetch_view view_name, opts, &block
         retryable = true
         begin
-          database.view(view_name, opts, &block)
+          design_doc.view(view_name, opts, &block)
           # the design doc could have been deleted by a rouge process
         rescue RestClient::ResourceNotFound => e
           if retryable
@@ -369,10 +402,14 @@ module CouchRest
         end
       end
 
+      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 = []
-        generated_design_doc['views'].each do |name, view|
+        design_doc['views'].each do |name, view|
           funcs << "#{name}/#{view['map']}#{view['reduce']}"
         end
         md5 = Digest::MD5.hexdigest(funcs.sort.join(''))
@@ -395,16 +432,18 @@ module CouchRest
       end
 
       def refresh_design_doc
-        did = "_design/#{design_doc_slug}"
+        did = design_doc_id
         saved = database.get(did) rescue nil
         if saved
-          generated_design_doc['views'].each do |name, view|
+          design_doc['views'].each do |name, view|
             saved['views'][name] = view
           end
           database.save(saved)
         else
-          generated_design_doc['_id'] = did
-          database.save(generated_design_doc)
+          design_doc['_id'] = did
+          design_doc.delete('_rev')
+          design_doc.database = database
+          design_doc.save
         end
         self.design_doc_fresh = true
       end
@@ -416,46 +455,42 @@ module CouchRest
       self.class.database
     end
 
-    # alias for self['_id']
-    def id
-      self['_id']
-    end
-
-    # alias for self['_rev']      
-    def rev
-      self['_rev']
-    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
+    # 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 :#{key}" unless self.respond_to?("#{k}=")
+        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
-      save
     end
 
-    # returns true if the document has never been saved
-    def new_record?
-      !rev
+    # 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
 
-    # 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.
-    def save
-      if new_record?
-        create
-      else
-        update
-      end
+    # for compatibility with old-school frameworks
+    alias :new_record? :new_document? 
+
+    # Overridden to set the unique ID.
+    def save bulk = false
+      set_unique_id if new_document? && self.respond_to?(:set_unique_id)
+      super(bulk)
+    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 :delete callbacks.
+    # 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
@@ -467,35 +502,61 @@ module CouchRest
       result['ok']
     end
 
-    protected
-
-    # Saves a document for the first time, after running the before(:create)
-    # callbacks, and applying the unique_id.
-    def create
-      set_unique_id if respond_to?(:set_unique_id) # hack
-      save_doc
+    # creates a file attachment to the current doc
+    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)
+      Base64.decode64(database.fetch_attachment(self.id, 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
 
-    # Saves the document and runs the :update callbacks.
-    def update
-      save_doc
+    # 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
 
     private
 
-    def save_doc
-      result = database.save self
-      if result['ok']
-        self['_id'] = result['id']
-        self['_rev'] = result['rev']
-      end
-      result['ok']
-    end
-
     def apply_defaults
+      return unless new_document?
       if self.class.default
         self.class.default.each do |k,v|
-          self[k.to_s] = v
+          unless self.key?(k.to_s)
+            if v.class == Proc
+              self[k.to_s] = v.call
+            else
+              self[k.to_s] = Marshal.load(Marshal.dump(v))
+            end
+          end
         end
       end
     end
@@ -506,19 +567,41 @@ module CouchRest
       self.class.casts.each do |k,v|
         next unless self[k]
         target = v[:as]
+        v[:send] || 'new'
         if target.is_a?(Array)
           klass = ::Extlib::Inflection.constantize(target[0])
           self[k] = self[k].collect do |value|
-            klass.new(value)
+            (!v[:send] && klass == Time) ? Time.parse(value) : klass.send((v[:send] || 'new'), value)
           end
         else
-          self[k] = ::Extlib::Inflection.constantize(target).new(self[k])
+          self[k] = if (!v[:send] && target == 'Time') 
+            Time.parse(self[k])
+          else
+            ::Extlib::Inflection.constantize(target).send((v[:send] || 'new'), self[k])
+          end
         end
       end
     end
 
+    def encode_attachment(data)
+      Base64.encode64(data).gsub(/\r|\n/,'')
+    end
+    
+    def get_mime_type(file)
+      MIME::Types.type_for(file.path).empty? ? 
+        'text\/plain' : MIME::Types.type_for(file.path).first.content_type.gsub(/\//,'\/')
+    end
+
+    def set_attachment_attr(args)
+      content_type = args[:content_type] ? args[:content_type] : get_mime_type(args[:file])
+      self['_attachments'][args[:name]] = {
+        'content-type' => content_type,
+        'data'         => encode_attachment(args[:file].read)
+      }
+    end
+
     include ::Extlib::Hook
-    register_instance_hooks :save, :create, :update, :destroy
+    register_instance_hooks :save, :destroy
 
   end # class Model
-end # module CouchRest
+end # module CouchRest

data/lib/couchrest/core/server.rb

@@ -1,7 +1,7 @@
 module CouchRest
   class Server
     attr_accessor :uri, :uuid_batch_count
-    def initialize server = 'http://localhost:5984', uuid_batch_count = 1000
+    def initialize server = 'http://127.0.0.1:5984', uuid_batch_count = 1000
       @uri = server
       @uuid_batch_count = uuid_batch_count
     end

data/lib/couchrest/core/view.rb

@@ -0,0 +1,4 @@
+module CouchRest
+  class View
+  end
+end

data/lib/couchrest/helper/pager.rb

@@ -5,13 +5,13 @@ module CouchRest
       @db = db
     end
     
-    def all_docs(count=100, &block)
+    def all_docs(limit=100, &block)
       startkey = nil
       oldend = nil
       
-      while docrows = request_all_docs(count+1, startkey)        
+      while docrows = request_all_docs(limit+1, startkey)        
         startkey = docrows.last['key']
-        docrows.pop if docrows.length > count
+        docrows.pop if docrows.length > limit
         if oldend == startkey
           break
         end
@@ -20,13 +20,13 @@ module CouchRest
       end
     end
     
-    def key_reduce(view, count, firstkey = nil, lastkey = nil, &block)
+    def key_reduce(view, limit=2000, firstkey = nil, lastkey = nil, &block)
       # start with no keys
       startkey = firstkey
       # lastprocessedkey = nil
       keepgoing = true
       
-      while keepgoing && viewrows = request_view(view, count, startkey)
+      while keepgoing && viewrows = request_view(view, limit, startkey)
         startkey = viewrows.first['key']
         endkey = viewrows.last['key']
 
@@ -37,7 +37,7 @@ module CouchRest
           # we need to do an offset thing to find the next startkey
           # otherwise we just get stuck
           lastdocid = viewrows.last['id']
-          fornextloop = @db.view(view, :startkey => startkey, :startkey_docid => lastdocid, :count => 2)['rows']
+          fornextloop = @db.view(view, :startkey => startkey, :startkey_docid => lastdocid, :limit => 2)['rows']
 
           newendkey = fornextloop.last['key']
           if (newendkey == endkey)
@@ -79,18 +79,18 @@ module CouchRest
 
     private
     
-    def request_all_docs count, startkey = nil
+    def request_all_docs limit, startkey = nil
       opts = {}
-      opts[:count] = count if count
+      opts[:limit] = limit if limit
       opts[:startkey] = startkey if startkey      
       results = @db.documents(opts)
       rows = results['rows']
       rows unless rows.length == 0
     end
 
-    def request_view view, count = nil, startkey = nil, endkey = nil
+    def request_view view, limit = nil, startkey = nil, endkey = nil
       opts = {}
-      opts[:count] = count if count
+      opts[:limit] = limit if limit
       opts[:startkey] = startkey if startkey
       opts[:endkey] = endkey if endkey
       

data/lib/couchrest/monkeypatches.rb

@@ -8,7 +8,7 @@ class Time
 
   def to_json(options = nil)
     u = self.utc
-    %("#{u.strftime("%Y/%m/%d %H:%M:%S +0000")}")
+    %("#{u.strftime("%Y/%m/%d %H:%M:%S.#{u.usec} +0000")}")
   end
 
   # Decodes the JSON time format to a UTC time.

data/lib/couchrest.rb

@@ -15,7 +15,7 @@
 require "rubygems"
 require 'json'
 require 'rest_client'
-require 'extlib'
+# require 'extlib'
 
 $:.unshift File.dirname(__FILE__) unless
   $:.include?(File.dirname(__FILE__)) ||
@@ -26,8 +26,13 @@ require 'couchrest/monkeypatches'
 
 # = CouchDB, close to the metal
 module CouchRest
+  VERSION = '0.12.2'
+  
   autoload :Server,       'couchrest/core/server'
   autoload :Database,     'couchrest/core/database'
+  autoload :Document,     'couchrest/core/document'
+  autoload :Design,     'couchrest/core/design'
+  autoload :View,         'couchrest/core/view'
   autoload :Model,        'couchrest/core/model'
   autoload :Pager,        'couchrest/helper/pager'
   autoload :FileManager,  'couchrest/helper/file_manager'
@@ -69,12 +74,17 @@ module CouchRest
       db = nil if db && db.empty?
 
       {
-        :host => host || "localhost:5984",
+        :host => host || "127.0.0.1:5984",
         :database => db,
         :doc => docid
       }
     end
 
+    # set proxy for RestClient to use
+    def proxy url
+      RestClient.proxy = url
+    end
+
     # ensure that a database exists
     # creates it if it isn't already there
     # returns it after it's been created
@@ -107,6 +117,14 @@ module CouchRest
     def delete uri
       JSON.parse(RestClient.delete(uri))
     end
+    
+    def copy uri, destination
+      JSON.parse(RestClient.copy(uri, {'Destination' => destination}))
+    end
+    
+    def move uri, destination
+      JSON.parse(RestClient.move(uri, {'Destination' => destination}))
+    end
   
     def paramify_url url, params = {}
       if params && !params.empty?