norr-couchrest 0.30.4 → 0.33.01

data/lib/couchrest/middlewares/logger.rb

@@ -0,0 +1,263 @@
+####################################
+# USAGE
+#
+# in your rack.rb file
+# require this file and then:
+#
+# couch = CouchRest.new
+# LOG_DB = couch.database!('couchrest-logger')
+# use CouchRest::Logger, LOG_DB
+# 
+# Note:
+# to require just this middleware, if you have the gem installed do:
+# require 'couchrest/middlewares/logger'
+#
+# For log processing examples, see examples at the bottom of this file
+
+module CouchRest
+  class Logger 
+    
+    def self.log
+      Thread.current["couchrest.logger"] ||= {:queries => []}
+    end
+        
+    def initialize(app, db=nil)
+      @app = app
+      @db = db
+    end
+    
+    def self.record(log_info)
+      log[:queries] << log_info
+    end
+    
+    def log
+      Thread.current["couchrest.logger"] ||= {:queries => []}
+    end
+    
+    def reset_log
+      Thread.current["couchrest.logger"] = nil
+    end
+ 
+    def call(env)
+      reset_log
+      log['started_at'] = Time.now
+      log['env'] = env
+      log['url'] = 'http://' + env['HTTP_HOST'] + env['REQUEST_URI'] 
+      response = @app.call(env)
+      log['ended_at'] = Time.now
+      log['duration'] = log['ended_at'] - log['started_at']
+      # let's report the log in a different thread so we don't slow down the app
+      @db ? Thread.new(@db, log){|db, rlog| db.save_doc(rlog);} : p(log.inspect)
+      response
+    end
+  end
+end
+
+# inject our logger into CouchRest HTTP abstraction layer
+module HttpAbstraction
+ 
+  def self.get(uri, headers=nil)
+    start_query = Time.now
+    log = {:method => :get, :uri => uri, :headers => headers}
+    response = super(uri, headers=nil)
+    end_query = Time.now
+    log[:duration] = (end_query - start_query)
+    CouchRest::Logger.record(log)
+    response
+  end 
+  
+  def self.post(uri, payload, headers=nil)
+    start_query = Time.now
+    log = {:method => :post, :uri => uri, :payload =>  (payload ? (JSON.load(payload) rescue 'parsing error') : nil), :headers => headers}
+    response = super(uri, payload, headers=nil)
+    end_query = Time.now
+    log[:duration] = (end_query - start_query)
+    CouchRest::Logger.record(log)
+    response
+  end
+   
+  def self.put(uri, payload, headers=nil)
+    start_query = Time.now
+    log = {:method => :put, :uri => uri, :payload => (payload ? (JSON.load(payload) rescue 'parsing error') : nil), :headers => headers}
+    response = super(uri, payload, headers=nil)
+    end_query = Time.now
+    log[:duration] = (end_query - start_query)
+    CouchRest::Logger.record(log)
+    response
+  end
+  
+  def self.delete(uri, headers=nil)
+    start_query = Time.now
+    log = {:method => :delete, :uri => uri, :headers => headers}
+    response = super(uri, headers=nil)
+    end_query = Time.now
+    log[:duration] = (end_query - start_query)
+    CouchRest::Logger.record(log)
+    response
+  end   
+  
+end 
+
+
+# Advanced usage example 
+#
+#
+# # DB VIEWS 
+# by_url = {
+#   :map => 
+#     "function(doc) {
+#       if(doc['url']){ emit(doc['url'], 1) };
+#     }",
+#  :reduce => 
+#     'function (key, values, rereduce) {
+#        return(sum(values));
+#     };'
+# }
+# req_duration = {
+#   :map => 
+#     "function(doc) {
+#       if(doc['duration']){ emit(doc['url'], doc['duration']) };
+#     }",
+#  :reduce => 
+#     'function (key, values, rereduce) {
+#        return(sum(values)/values.length);
+#     };'
+# }
+# 
+# query_duration = {
+#   :map => 
+#     "function(doc) {
+#           if(doc['queries']){ 
+#             doc.queries.forEach(function(query){
+#     if(query['duration'] && query['method']){ 
+#               emit(query['method'], query['duration'])
+#     }
+#             });
+#           };
+#          }" ,
+#    :reduce => 
+#       'function (key, values, rereduce) {
+#         return(sum(values)/values.length);
+#       };'
+# }
+# 
+# action_queries = {
+#   :map => 
+#     "function(doc) {
+#           if(doc['queries']){
+#              emit(doc['url'], doc['queries'].length)
+#           };
+#          }",
+#  :reduce => 
+#     'function (key, values, rereduce) {
+#       return(sum(values)/values.length);
+#     };'
+# }  
+# 
+# action_time_spent_in_db = {
+#   :map => 
+#     "function(doc) {
+#           if(doc['queries']){
+#             var totalDuration = 0;
+#             doc.queries.forEach(function(query){
+#               totalDuration += query['duration']
+#             })
+#              emit(doc['url'], totalDuration)
+#           };
+#          }",
+#  :reduce => 
+#     'function (key, values, rereduce) {
+#       return(sum(values)/values.length);
+#     };'
+# }
+# 
+# show_queries =  %Q~function(doc, req) {
+#                    var body = ""
+#                    body += "<h1>" + doc['url'] + "</h1>"
+#                    body += "<h2>Request duration in seconds: " + doc['duration'] + "</h2>"
+#                    body += "<h3>" + doc['queries'].length + " queries</h3><ul>"
+#                    if (doc.queries){
+#                      doc.queries.forEach(function(query){
+#                        body += "<li>"+ query['uri'] +"</li>"
+#                      });
+#                    };
+#                    body += "</ul>"
+#                    if(doc){ return { body: body} }
+#                  }~
+# 
+# 
+# couch = CouchRest.new
+# LOG_DB = couch.database!('couchrest-logger')   
+# design_doc = LOG_DB.get("_design/stats") rescue nil
+# LOG_DB.delete_doc design_doc rescue nil
+# LOG_DB.save_doc({
+#   "_id" => "_design/stats",
+#   :views => {
+#     :by_url           => by_url,
+#     :request_duration => req_duration,
+#     :query_duration   => query_duration,
+#     :action_queries   => action_queries,
+#     :action_time_spent_in_db => action_time_spent_in_db
+#   },
+#  :shows => {
+#    :queries => show_queries
+#  }
+# })
+# 
+# module CouchRest
+#   class Logger
+#     
+#     def self.roundup(value)
+#       begin
+#         value = Float(value)
+#         (value * 100).round.to_f / 100
+#       rescue
+#         value
+#       end
+#     end
+#     
+#     # Usage example:
+#     # CouchRest::Logger.average_request_duration(LOG_DB)['rows'].first['value']
+#     def self.average_request_duration(db)
+#       raw = db.view('stats/request_duration', :reduce => true)
+#       (raw.has_key?('rows') && !raw['rows'].empty?) ? roundup(raw['rows'].first['value']) : 'not available yet'
+#     end
+#     
+#     def self.average_query_duration(db)
+#       raw =  db.view('stats/query_duration', :reduce => true)
+#       (raw.has_key?('rows') && !raw['rows'].empty?) ? roundup(raw['rows'].first['value']) : 'not available yet'
+#     end   
+#     
+#     def self.average_get_query_duration(db)
+#       raw = db.view('stats/query_duration', :key => 'get', :reduce => true)
+#       (raw.has_key?('rows') && !raw['rows'].empty?) ? roundup(raw['rows'].first['value']) : 'not available yet'
+#     end  
+#     
+#     def self.average_post_query_duration(db)
+#       raw = db.view('stats/query_duration', :key => 'post', :reduce => true)
+#       (raw.has_key?('rows') && !raw['rows'].empty?) ? roundup(raw['rows'].first['value']) : 'not available yet'
+#     end 
+#     
+#     def self.average_queries_per_action(db)
+#       raw = db.view('stats/action_queries', :reduce => true)
+#       (raw.has_key?('rows') && !raw['rows'].empty?) ? roundup(raw['rows'].first['value']) : 'not available yet'
+#     end
+#     
+#     def self.average_db_time_per_action(db)
+#      raw = db.view('stats/action_time_spent_in_db', :reduce => true)
+#      (raw.has_key?('rows') && !raw['rows'].empty?) ? roundup(raw['rows'].first['value']) : 'not available yet'
+#     end
+#     
+#     def self.stats(db)
+#       Thread.new(db){|db|
+#         puts "===  STATS  ===\n"
+#         puts "average request duration: #{average_request_duration(db)}\n"
+#         puts "average query duration: #{average_query_duration(db)}\n"
+#         puts "average queries per action : #{average_queries_per_action(db)}\n"
+#         puts "average time spent in DB (per action): #{average_db_time_per_action(db)}\n"
+#         puts "===============\n"   
+#      }
+#     end
+#     
+#   end
+# end             

data/lib/couchrest/mixins/attachments.rb

@@ -19,9 +19,9 @@ module CouchRest
       end
 
       # deletes an attachment directly from couchdb
-      def delete_attachment(name)
+      def delete_attachment(name, force=false)
         raise ArgumentError, "doc.database required to delete_attachment" unless database
-        result = database.delete_attachment(self, name)
+        result = database.delete_attachment(self, name, force)
         self['_rev'] = result['rev']
         result['ok']
       end

data/lib/couchrest/mixins/class_proxy.rb

@@ -59,6 +59,10 @@ module CouchRest
           @klass.all({:database => @database}.merge(opts), &block)
         end
         
+        def count(opts = {}, &block)
+          @klass.all({:database => @database, :raw => true, :limit => 0}.merge(opts), &block)['total_rows']
+        end
+        
         def first(opts = {})
           @klass.first({:database => @database}.merge(opts))
         end
@@ -100,7 +104,7 @@ module CouchRest
         end
         
         def refresh_design_doc
-          @klass.refresh_design_doc
+          @klass.refresh_design_doc_on(@database)
         end
         
         def save_design_doc

data/lib/couchrest/mixins/collection.rb

@@ -1,5 +1,14 @@
 module CouchRest
   module Mixins
+    module PaginatedResults
+      def amount_pages
+        @amount_pages ||= 0
+      end   
+      def amount_pages=(value)
+        @amount_pages = value
+      end               
+    end
+    
     module Collection
   
       def self.included(base)
@@ -83,6 +92,8 @@ module CouchRest
 
         DEFAULT_PAGE = 1
         DEFAULT_PER_PAGE = 30
+        
+        attr_accessor :amount_pages
 
         # Create a new CollectionProxy to represent the specified view.  If a
         # container class is specified, the proxy will create an object of the
@@ -110,9 +121,13 @@ module CouchRest
         # See Collection.paginate
         def paginate(options = {})
           page, per_page = parse_options(options)
-          results = @database.view(@view_name, pagination_options(page, per_page))
+          results = @database.view(@view_name, pagination_options(page, per_page)) 
+          @amount_pages ||= (results['total_rows'].to_f / per_page.to_f).ceil
           remember_where_we_left_off(results, page)
-          convert_to_container_array(results)
+          results = convert_to_container_array(results)
+          results.extend(PaginatedResults)
+          results.amount_pages = @amount_pages
+          results
         end
 
         # See Collection.paginated_each
@@ -178,7 +193,7 @@ module CouchRest
           @target.inspect
         end
 
-        def convert_to_container_array(results)
+        def convert_to_container_array(results) 
           if @container_class.nil?
             results
           else
@@ -209,12 +224,14 @@ module CouchRest
 
         def remember_where_we_left_off(results, page)
           last_row = results['rows'].last
-          @last_key = last_row['key']
-          @last_docid = last_row['id']
+          if last_row
+            @last_key = last_row['key']
+            @last_docid = last_row['id']
+          end
           @last_page = page
         end
       end
 
     end
   end
-end
+end

data/lib/couchrest/mixins/design_doc.rb

@@ -45,6 +45,11 @@ module CouchRest
           save_design_doc
         end
 
+        def refresh_design_doc_on(db)
+          reset_design_doc
+          save_design_doc_on(db)
+        end
+
         # Save the design doc onto the default database, and update the
         # design_doc attribute
         def save_design_doc

data/lib/couchrest/mixins/document_queries.rb

@@ -12,16 +12,14 @@ module CouchRest
         # name of the current class. Take the standard set of
         # CouchRest::Database#view options.
         def all(opts = {}, &block)
-          view(:all, {:reduce => false}.merge(opts), &block)
+          view(:all, opts, &block)
         end
         
         # Returns the number of documents that have the "couchrest-type" field
         # equal to the name of the current class. Takes the standard set of 
         # CouchRest::Database#view options
         def count(opts = {}, &block)
-          result = all({:reduce => true}.merge(opts), &block)['rows']
-          return 0 if result.empty?
-          result.first['value']
+          all({:raw => true, :limit => 0}.merge(opts), &block)['total_rows']
         end
         
         # Load the first document that have the "couchrest-type" field equal to
@@ -41,7 +39,38 @@ module CouchRest
         end
         
         # Load a document from the database by id
+        # No exceptions will be raised if the document isn't found
+        #
+        # ==== Returns
+        # Object:: if the document was found
+        # or
+        # Nil::
+        # 
+        # === Parameters
+        # id<String, Integer>:: Document ID
+        # db<Database>:: optional option to pass a custom database to use
         def get(id, db = database)
+          begin
+            doc = db.get id
+          rescue
+            nil
+          else
+            new(doc)
+          end
+        end
+        
+        # Load a document from the database by id
+        # An exception will be raised if the document isn't found
+        #
+        # ==== Returns
+        # Object:: if the document was found
+        # or
+        # Exception
+        # 
+        # === Parameters
+        # id<String, Integer>:: Document ID
+        # db<Database>:: optional option to pass a custom database to use
+        def get!(id, db = database)
           doc = db.get id
           new(doc)
         end

data/lib/couchrest/mixins/properties.rb

@@ -56,7 +56,6 @@ module CouchRest
       def cast_keys
         return unless self.class.properties
         self.class.properties.each do |property|
-          
           next unless property.casted
           key = self.has_key?(property.name) ? property.name : property.name.to_sym
           # Don't cast the property unless it has a value
@@ -73,9 +72,15 @@ module CouchRest
           else
             # Auto parse Time objects
             self[property.name] = if ((property.init_method == 'new') && target == 'Time')
-              # Using custom time parsing method because Ruby's default method is toooo slow 
-              #self[key].is_a?(String) ? Time.mktime_with_offset(self[key].dup) : self[key]
-              self[key].is_a?(String) ? Time.parse(self[key].dup) : self[key]
+              # Using custom time parsing method because Ruby's default method is toooo slow
+              self[key].is_a?(String) ? Time.mktime_with_offset(self[key].dup) : self[key]
+              #self[key].is_a?(String) ? Time.parse(self[key].dup) : self[key]
+            # Float instances don't get initialized with #new
+            elsif ((property.init_method == 'new') && target == 'Float')
+              cast_float(self[key])
+            # 'boolean' type is simply used to generate a property? accessor method
+            elsif ((property.init_method == 'new') && target == 'boolean')
+              self[key]
             else
               # Let people use :send as a Time parse arg
               klass = ::CouchRest.constantize(target)
@@ -85,6 +90,15 @@ module CouchRest
           end 
           
         end
+        
+        def cast_float(value)
+          begin 
+            Float(value)
+          rescue 
+            value
+          end
+        end
+        
       end
       
       module ClassMethods
@@ -118,6 +132,18 @@ module CouchRest
               end
             EOS
 
+            if property.type == 'boolean'
+              class_eval <<-EOS, __FILE__, __LINE__
+                def #{property.name}?
+                  if self['#{property.name}'].nil? || self['#{property.name}'] == false || self['#{property.name}'].to_s.downcase == 'false'
+                    false
+                  else
+                    true
+                  end
+                end
+              EOS
+            end
+
             if property.alias
               class_eval <<-EOS, __FILE__, __LINE__
                 alias #{property.alias.to_sym} #{property.name.to_sym}