jrun-couchrest 0.12.6 → 0.17.1

data/lib/couchrest/mixins/views.rb

@@ -0,0 +1,168 @@
+module CouchRest
+  module Mixins
+    module Views
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+        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 || (opts.has_key?(:include_docs) && opts[:include_docs] == false)
+            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/monkeypatches.rb

@@ -1,3 +1,6 @@
+require File.join(File.dirname(__FILE__), 'support', 'class')
+require File.join(File.dirname(__FILE__), 'support', 'blank')
+
 # 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
@@ -28,13 +31,19 @@ if RUBY_VERSION.to_f < 1.9
   class Net::BufferedIO #:nodoc:
     alias :old_rbuf_fill :rbuf_fill
     def rbuf_fill
-      begin
-        @rbuf << @io.read_nonblock(65536)
-      rescue Errno::EWOULDBLOCK
-        if IO.select([@io], nil, nil, @read_timeout)
+      if @io.respond_to?(:read_nonblock)
+        begin
           @rbuf << @io.read_nonblock(65536)
-        else
-          raise Timeout::TimeoutError
+        rescue Errno::EWOULDBLOCK
+          if IO.select([@io], nil, nil, @read_timeout)
+            retry
+          else
+            raise Timeout::TimeoutError
+          end
+        end
+      else
+        timeout(@read_timeout) do
+          @rbuf << @io.sysread(65536)
         end
       end
     end
@@ -53,47 +62,58 @@ module RestClient
     :url => url,
     :headers => headers)
   end
-  
-  class Request 
-    def transmit(uri, req, payload)
-			setup_credentials(req)
-			
-			Thread.current[:host] ||= uri.host
-      Thread.current[:port] ||= uri.port
-
-			net = net_http_class.new(uri.host, uri.port)
-      
-      if Thread.current[:connection].nil? || Thread.current[:host] != uri.host
-        Thread.current[:connection].finish if (Thread.current[:connection] && Thread.current[:connection].started?)
-        net.use_ssl = uri.is_a?(URI::HTTPS)
-        net.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        Thread.current[:connection] = net
-        Thread.current[:connection].start
-      end
-
-			display_log request_log
-      http = Thread.current[:connection]
 
-      http.read_timeout = @timeout if @timeout
-      begin
-  			res = http.request(req, payload)
-  		rescue
-  		  # p "Net::HTTP connection failed, reconnecting"
-  		  Thread.current[:connection].finish
-  		  http = Thread.current[:connection] = net
-        Thread.current[:connection].start
-        res = http.request(req, payload)
-        display_log response_log(res)
-  			process_result res
-		  else
-  			display_log response_log(res)
-  			process_result res
-  		end
-			
-		rescue EOFError
-			raise RestClient::ServerBrokeConnection
-		rescue Timeout::Error
-			raise RestClient::RequestTimeout
-		end
-  end
+#   class Request
+#     
+#     def establish_connection(uri)
+#       Thread.current[:connection].finish if (Thread.current[:connection] && Thread.current[:connection].started?)
+#       p net_http_class
+#       net = net_http_class.new(uri.host, uri.port)
+#       net.use_ssl = uri.is_a?(URI::HTTPS)
+#       net.verify_mode = OpenSSL::SSL::VERIFY_NONE
+#       Thread.current[:connection] = net
+#       Thread.current[:connection].start
+#       Thread.current[:connection]
+#     end
+#     
+#     def transmit(uri, req, payload)
+#       setup_credentials(req)
+#       
+#       Thread.current[:host] ||= uri.host
+#       Thread.current[:port] ||= uri.port
+#       
+#       if (Thread.current[:connection].nil? || (Thread.current[:host] != uri.host))
+#         p "establishing a connection"
+#         establish_connection(uri)
+#       end
+# 
+#       display_log request_log
+#       http = Thread.current[:connection]
+#       http.read_timeout = @timeout if @timeout
+#       
+#       begin
+#         res = http.request(req, payload)
+#       rescue
+#         p "Net::HTTP connection failed, reconnecting"
+#         establish_connection(uri)
+#         http = Thread.current[:connection]
+#         require 'ruby-debug'
+#         debugger
+#         req.body_stream = nil
+#         
+#         res = http.request(req, payload)
+#         display_log response_log(res)
+#         result res
+#       else
+#         display_log response_log(res)
+#         process_result res
+#       end
+#       
+#     rescue EOFError
+#       raise RestClient::ServerBrokeConnection
+#     rescue Timeout::Error
+#       raise RestClient::RequestTimeout
+#     end
+#   end
+  
 end

data/lib/couchrest/more/casted_model.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), '..', 'mixins', 'properties')
+
+module CouchRest
+  module CastedModel
+    
+    def self.included(base)
+      base.send(:include, CouchRest::Mixins::Properties)
+      base.send(:attr_accessor, :casted_by)
+    end
+    
+    def initialize(keys={})
+      super
+      keys.each do |k,v|
+        self[k.to_s] = v
+      end if keys
+      apply_defaults # defined in CouchRest::Mixins::Properties
+      # cast_keys      # defined in CouchRest::Mixins::Properties
+    end
+    
+    def []= key, value
+      super(key.to_s, value)
+    end
+    
+    def [] key
+      super(key.to_s)
+    end
+  end
+end

data/lib/couchrest/more/extended_document.rb

@@ -0,0 +1,217 @@
+begin
+  # still required for Time parsing and pluralization in the validation
+  require 'extlib'
+rescue 
+  puts "CouchRest::ExtendedDocument still requires extlib (not for much longer). 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::Callbacks
+    include CouchRest::Mixins::DocumentQueries    
+    include CouchRest::Mixins::Views
+    include CouchRest::Mixins::DesignDoc
+    include CouchRest::Mixins::ExtendedAttachments
+    
+    def self.inherited(subklass)
+      subklass.send(:include, CouchRest::Mixins::Properties)
+    end
+    
+    # Accessors
+    attr_accessor :casted_by
+    
+    # Callbacks
+    define_callbacks :create
+    define_callbacks :save
+    define_callbacks :update
+    define_callbacks :destroy
+    
+    def initialize(passed_keys={})
+      apply_defaults # defined in CouchRest::Mixins::Properties
+      super
+      cast_keys      # defined in CouchRest::Mixins::Properties
+      unless self['_id'] && self['_rev']
+        self['couchrest-type'] = self.class.to_s
+      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 self.timestamps!
+      class_eval <<-EOS, __FILE__, __LINE__
+        property(:updated_at, :read_only => true, :cast_as => 'Time', :auto_validation => false)
+        property(:created_at, :read_only => true, :cast_as => 'Time', :auto_validation => false)
+        
+        save_callback :before do |object|
+          object['updated_at'] = Time.now
+          object['created_at'] = object['updated_at'] if object.new_document?
+        end
+      EOS
+    end
+  
+    # Name a method that will be called before the document is first saved,
+    # which returns a string to be used for the document's <tt>_id</tt>.
+    # Because CouchDB enforces a constraint that each id must be unique,
+    # this can be used to enforce eg: uniq usernames. Note that this id
+    # must be globally unique across all document types which share a
+    # database, so if you'd like to scope uniqueness to this class, you
+    # should use the class name as part of the unique id.
+    def self.unique_id method = nil, &block
+      if method
+        define_method :set_unique_id do
+          self['_id'] ||= self.send(method)
+        end
+      elsif block
+        define_method :set_unique_id do
+          uniqid = block.call(self)
+          raise ArgumentError, "unique_id block must not return nil" if uniqid.nil?
+          self['_id'] ||= uniqid
+        end
+      end
+    end
+    
+    # Temp solution to make the view_by methods available
+    def self.method_missing(m, *args)
+      if has_view?(m)
+        query = args.shift || {}
+        view(m, query, *args)
+      else
+        super
+      end
+    end
+    
+    ### instance methods
+    
+    # Returns the Class properties
+    #
+    # ==== Returns
+    # Array:: the list of properties for the instance
+    def properties
+      self.class.properties
+    end
+    
+    # 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 property :#{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?
+    
+    # Trigger the callbacks (before, after, around)
+    # and create the document
+    # It's important to have a create callback since you can't check if a document
+    # was new after you saved it
+    #
+    # When creating a document, both the create and the save callbacks will be triggered.
+    def create(bulk = false)
+      caught = catch(:halt)  do
+        _run_create_callbacks do
+            _run_save_callbacks do
+              create_without_callbacks(bulk)
+          end
+        end
+      end
+    end
+    
+    # unlike save, create returns the newly created document
+    def create_without_callbacks(bulk =false)
+      raise ArgumentError, "a document requires a database to be created to (The document or the #{self.class} default database were not set)" unless database
+      set_unique_id if new_document? && self.respond_to?(:set_unique_id)
+      result = database.save_doc(self, bulk)
+      (result["ok"] == true) ? self : false
+    end
+    
+    # Creates the document in the db. Raises an exception
+    # if the document is not created properly.
+    def create!
+      raise "#{self.inspect} failed to save" unless self.create
+    end
+    
+    # Trigger the callbacks (before, after, around)
+    # only if the document isn't new
+    def update(bulk = false)
+      caught = catch(:halt)  do
+        if self.new_document?
+          save(bulk)
+        else
+          _run_update_callbacks do
+            _run_save_callbacks do
+              save_without_callbacks(bulk)
+            end
+          end
+        end
+      end
+    end
+    
+    # Trigger the callbacks (before, after, around)
+    # and save the document
+    def save(bulk = false)
+      caught = catch(:halt)  do
+        if self.new_document?
+          _run_save_callbacks do
+            save_without_callbacks(bulk)
+          end
+        else
+          update(bulk)
+        end
+      end
+    end
+    
+    # Overridden to set the unique ID.
+    # Returns a boolean value
+    def save_without_callbacks(bulk = false)
+      raise ArgumentError, "a document requires a database to be saved to (The document or the #{self.class} default database were not set)" unless database
+      set_unique_id if new_document? && self.respond_to?(:set_unique_id)
+      result = database.save_doc(self, bulk)
+      result["ok"] == true
+    end
+    
+    # Saves the document to the db using save. Raises an exception
+    # if the document is not saved properly.
+    def save!
+      raise "#{self.inspect} failed to save" unless self.save
+    end
+
+    # Deletes the document from the database. Runs the :destroy callbacks.
+    # Removes the <tt>_id</tt> and <tt>_rev</tt> fields, preparing the
+    # document to be saved to a new <tt>_id</tt>.
+    def destroy(bulk=false)
+      caught = catch(:halt)  do
+        _run_destroy_callbacks do
+          result = database.delete_doc(self, bulk)
+          if result['ok']
+            self.delete('_rev')
+            self.delete('_id')
+          end
+          result['ok']
+        end
+      end
+    end
+    
+  end
+end