mattetti-couchrest 0.2.1.0 → 0.13

data/lib/couchrest/mixins/callbacks.rb

@@ -1,7 +1,6 @@
 require File.join(File.dirname(__FILE__), '..', 'support', 'class')
 
 # Extracted from ActiveSupport::Callbacks written by Yehuda Katz
-# http://github.com/wycats/rails/raw/abstract_controller/activesupport/lib/active_support/new_callbacks.rb
 # http://github.com/wycats/rails/raw/18b405f154868204a8f332888871041a7bad95e1/activesupport/lib/active_support/callbacks.rb
 
 module CouchRest
@@ -12,7 +11,7 @@ module CouchRest
   #
   # Example:
   #   class Storage
-  #     include ActiveSupport::Callbacks
+  #     include CouchRest::Callbacks
   #
   #     define_callbacks :save
   #   end
@@ -46,7 +45,7 @@ module CouchRest
   #
   # Example:
   #   class Storage
-  #     include ActiveSupport::Callbacks
+  #     include CouchRest::Callbacks
   #
   #     define_callbacks :save
   #
@@ -86,8 +85,8 @@ module CouchRest
       klass.extend ClassMethods
     end
         
-    def run_callbacks(kind, options = {}, &blk)
-      send("_run_#{kind}_callbacks", &blk)
+    def run_callbacks(kind, options = {})
+      send("_run_#{kind}_callbacks")
     end
     
     class Callback
@@ -167,13 +166,9 @@ module CouchRest
       
       # This will supply contents for before and around filters, and no
       # contents for after filters (for the forward pass).
-      def start(key = nil, options = {})
-        object, terminator = (options || {}).values_at(:object, :terminator)
-        
+      def start(key = nil, object = nil)
         return if key && !object.send("_one_time_conditions_valid_#{@callback_id}?")
         
-        terminator ||= false
-        
         # options[0] is the compiled form of supplied conditions
         # options[1] is the "end" for the conditional
                 
@@ -182,14 +177,8 @@ module CouchRest
             # if condition    # before_save :filter_name, :if => :condition
             #   filter_name
             # end
-            filter = <<-RUBY_EVAL
-              unless halted
-                result = #{@filter}
-                halted ||= (#{terminator})
-              end
-            RUBY_EVAL
-            [@compiled_options[0], filter, @compiled_options[1]].compact.join("\n")
-          else
+            [@compiled_options[0], @filter, @compiled_options[1]].compact.join("\n")
+          elsif @compiled_options[0]
             # Compile around filters with conditions into proxy methods
             # that contain the conditions.
             #
@@ -207,8 +196,8 @@ module CouchRest
             
             name = "_conditional_callback_#{@kind}_#{next_id}"
             txt = <<-RUBY_EVAL
-              def #{name}(halted)
-                #{@compiled_options[0] || "if true"} && !halted
+              def #{name}
+                #{@compiled_options[0]}
                   #{@filter} do
                     yield self
                   end
@@ -218,16 +207,16 @@ module CouchRest
               end
             RUBY_EVAL
             @klass.class_eval(txt)
-            "#{name}(halted) do"
+            "#{name} do"
+          else
+            "#{@filter} do"
           end
         end
       end
       
       # This will supply contents for around and after filters, but not
       # before filters (for the backward pass).
-      def end(key = nil, options = {})
-        object = (options || {})[:object]
-        
+      def end(key = nil, object = nil)
         return if key && !object.send("_one_time_conditions_valid_#{@callback_id}?")
         
         if @kind == :around || @kind == :after
@@ -310,7 +299,7 @@ module CouchRest
     # This method_missing is supplied to catch callbacks with keys and create
     # the appropriate callback for future use.
     def method_missing(meth, *args, &blk)
-      if meth.to_s =~ /_run__([\w:]+)__(\w+)__(\w+)__callbacks/
+      if meth.to_s =~ /_run_(\w+)_(\w+)_(\w+)_callbacks/
         return self.class._create_and_run_keyed_callback($1, $2.to_sym, $3.to_sym, self, &blk)
       end
       super
@@ -318,31 +307,25 @@ module CouchRest
     
     # An Array with a compile method
     class CallbackChain < Array
-      def initialize(symbol)
-        @symbol = symbol
-      end
-      
-      def compile(key = nil, options = {})
+      def compile(key = nil, object = nil)
         method = []
-        method << "halted = false"
         each do |callback|
-          method << callback.start(key, options)
+          method << callback.start(key, object)
         end
-        method << "yield self if block_given?"
+        method << "yield self"
         reverse_each do |callback|
-          method << callback.end(key, options)
+          method << callback.end(key, object)
         end
         method.compact.join("\n")
       end
       
       def clone(klass)
-        chain = CallbackChain.new(@symbol)
-        chain.push(*map {|c| c.clone(klass)})
+        CallbackChain.new(map {|c| c.clone(klass)})
       end
     end
         
     module ClassMethods
-      CHAINS = {:before => :before, :around => :before, :after => :after} unless self.const_defined?("CHAINS")
+      CHAINS = {:before => :before, :around => :before, :after => :after}
       
       # Make the _run_save_callbacks method. The generated method takes
       # a block that it'll yield to. It'll call the before and around filters
@@ -355,18 +338,16 @@ module CouchRest
       # The _run_save_callbacks method can optionally take a key, which
       # will be used to compile an optimized callback method for each
       # key. See #define_callbacks for more information.
-      def _define_runner(symbol, str, options)        
-        str = <<-RUBY_EVAL
+      def _define_runner(symbol, str, options)
+        self.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
           def _run_#{symbol}_callbacks(key = nil)
             if key
-              send("_run__\#{self.class.name.split("::").last}__#{symbol}__\#{key}__callbacks") { yield if block_given? }
+              send("_run_\#{self.class}_#{symbol}_\#{key}_callbacks") { yield }
             else
               #{str}
             end
           end
         RUBY_EVAL
-  
-        class_eval str, __FILE__, __LINE__ + 1
         
         before_name, around_name, after_name = 
           options.values_at(:before, :after, :around)
@@ -378,18 +359,15 @@ module CouchRest
       def _create_and_run_keyed_callback(klass, kind, key, obj, &blk)
         @_keyed_callbacks ||= {}
         @_keyed_callbacks[[kind, key]] ||= begin
-          str = self.send("_#{kind}_callbacks").compile(key, :object => obj, :terminator => self.send("_#{kind}_terminator"))
-
+          str = self.send("_#{kind}_callbacks").compile(key, obj)
           self.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-            def _run__#{klass.split("::").last}__#{kind}__#{key}__callbacks
+            def _run_#{klass}_#{kind}_#{key}_callbacks
               #{str}
             end
           RUBY_EVAL
-                    
           true
         end
-                                  
-        obj.send("_run__#{klass.split("::").last}__#{kind}__#{key}__callbacks", &blk)
+        obj.send("_run_#{klass}_#{kind}_#{key}_callbacks", &blk)
       end
       
       # Define callbacks.
@@ -424,32 +402,20 @@ module CouchRest
       # method that took into consideration the per_key conditions. This
       # is a speed improvement for ActionPack.
       def define_callbacks(*symbols)
-        terminator = symbols.pop if symbols.last.is_a?(String)
         symbols.each do |symbol|
-          self.class_inheritable_accessor("_#{symbol}_terminator")
-          self.send("_#{symbol}_terminator=", terminator)
           self.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
             class_inheritable_accessor :_#{symbol}_callbacks
-            self._#{symbol}_callbacks = CallbackChain.new(:#{symbol})
+            self._#{symbol}_callbacks = CallbackChain.new
 
-            def self.#{symbol}_callback(*filters, &blk)
-              type = [:before, :after, :around].include?(filters.first) ? filters.shift : :before
+            def self.#{symbol}_callback(type, *filters, &blk)
               options = filters.last.is_a?(Hash) ? filters.pop : {}
               filters.unshift(blk) if block_given?
-              
-              filters.map! do |filter| 
-                # overrides parent class
-                self._#{symbol}_callbacks.delete_if {|c| c.matches?(type, :#{symbol}, filter)}
-                Callback.new(filter, type, options.dup, self, :#{symbol})
-              end
+              filters.map! {|f| Callback.new(f, type, options.dup, self, :#{symbol})}
               self._#{symbol}_callbacks.push(*filters)
-              _define_runner(:#{symbol}, 
-                self._#{symbol}_callbacks.compile(nil, :terminator => _#{symbol}_terminator), 
-                options)
+              _define_runner(:#{symbol}, self._#{symbol}_callbacks.compile, options)
             end
             
-            def self.skip_#{symbol}_callback(*filters, &blk)
-              type = [:before, :after, :around].include?(filters.first) ? filters.shift : :before
+            def self.skip_#{symbol}_callback(type, *filters, &blk)
               options = filters.last.is_a?(Hash) ? filters.pop : {}
               filters.unshift(blk) if block_given?
               filters.each do |filter|
@@ -462,22 +428,15 @@ module CouchRest
                 else
                   self._#{symbol}_callbacks.delete(filter)
                 end
-                _define_runner(:#{symbol}, 
-                  self._#{symbol}_callbacks.compile(nil, :terminator => _#{symbol}_terminator), 
-                  options)
+                _define_runner(:#{symbol}, self._#{symbol}_callbacks.compile, options)
               end
               
             end
             
-            def self.reset_#{symbol}_callbacks
-              self._#{symbol}_callbacks = CallbackChain.new(:#{symbol})
-              _define_runner(:#{symbol}, self._#{symbol}_callbacks.compile, {})
-            end
-            
             self.#{symbol}_callback(:before)
           RUBY_EVAL
         end
       end
     end
   end
-end
+end

data/lib/couchrest/mixins/design_doc.rb

@@ -14,9 +14,8 @@ module CouchRest
         end
 
         def design_doc_slug
-          return design_doc_slug_cache if (design_doc_slug_cache && design_doc_fresh)
+          return design_doc_slug_cache if design_doc_slug_cache && design_doc_fresh
           funcs = []
-          design_doc ||= Design.new(default_design_doc)
           design_doc['views'].each do |name, view|
             funcs << "#{name}/#{view['map']}#{view['reduce']}"
           end

data/lib/couchrest/mixins/document_queries.rb

@@ -16,7 +16,7 @@ module CouchRest
           unless design_doc_fresh
             refresh_design_doc
           end
-          view(:all, opts, &block)
+          view :all, opts, &block
         end
 
         # Load the first document that have the "couchrest-type" field equal to

data/lib/couchrest/mixins/extended_document_mixins.rb

@@ -2,5 +2,4 @@ require File.join(File.dirname(__FILE__), 'properties')
 require File.join(File.dirname(__FILE__), 'document_queries')
 require File.join(File.dirname(__FILE__), 'views')
 require File.join(File.dirname(__FILE__), 'design_doc')
-require File.join(File.dirname(__FILE__), 'validation')
-require File.join(File.dirname(__FILE__), 'extended_attachments')
+require File.join(File.dirname(__FILE__), 'validation')

data/lib/couchrest/mixins/properties.rb

@@ -40,8 +40,8 @@ module CouchRest
           key = self.has_key?(property.name) ? property.name : property.name.to_sym
           target = property.type
           if target.is_a?(Array)
-            next unless self[key]
             klass = ::CouchRest.constantize(target[0])
+            
             self[property.name] = self[key].collect do |value|
               # Auto parse Time objects
               obj = ( (property.init_method == 'new') && klass == Time) ? Time.parse(value) : klass.send(property.init_method, value)
@@ -55,14 +55,9 @@ module CouchRest
             else
               # Let people use :send as a Time parse arg
               klass = ::CouchRest.constantize(target)
-              # I'm not convince we should or should not create a new instance if we are casting a doc/extended doc without default value and nothing was passed
-              # unless (property.casted && 
-              #   (klass.superclass == CouchRest::ExtendedDocument || klass.superclass == CouchRest::Document) && 
-              #     (self[key].nil? || property.default.nil?))
               klass.send(property.init_method, self[key])
-              #end
             end
-            self[property.name].casted_by = self if self[property.name].respond_to?(:casted_by)
+            self[key].casted_by = self if self[key].respond_to?(:casted_by)
           end
         end
       end
@@ -70,7 +65,7 @@ module CouchRest
       module ClassMethods
         
         def property(name, options={})
-          define_property(name, options) unless self.properties.map{|p| p.name}.include?(name.to_s)
+          define_property(name, options) unless properties.map{|p| p.name}.include?(name.to_s)
         end
         
         protected

data/lib/couchrest/mixins/validation.rb

@@ -43,7 +43,6 @@ require File.join(dir, 'validators', 'format_validator')
 require File.join(dir, 'validators', 'length_validator')
 require File.join(dir, 'validators', 'numeric_validator')
 require File.join(dir, 'validators', 'method_validator')
-require File.join(dir, 'validators', 'confirmation_validator')
 
 module CouchRest
   module Validation
@@ -148,7 +147,7 @@ module CouchRest
     module ClassMethods
       include CouchRest::Validation::ValidatesPresent
       include CouchRest::Validation::ValidatesAbsent
-      include CouchRest::Validation::ValidatesIsConfirmed
+      # include CouchRest::Validation::ValidatesIsConfirmed
       # include CouchRest::Validation::ValidatesIsPrimitive
       # include CouchRest::Validation::ValidatesIsAccepted
       include CouchRest::Validation::ValidatesFormat

data/lib/couchrest/mixins/views.rb

@@ -95,7 +95,7 @@ module CouchRest
         end
 
         # Dispatches to any named view.
-        def view(name, query={}, &block)
+        def view name, query={}, &block
           unless design_doc_fresh
             refresh_design_doc
           end
@@ -128,9 +128,9 @@ module CouchRest
 
         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)
+        def fetch_view_with_docs name, opts, raw=false, &block
+          if raw
+            fetch_view name, opts, &block
           else
             begin
               view = fetch_view name, opts.merge({:include_docs => true}), &block
@@ -138,7 +138,7 @@ module CouchRest
             rescue
               # fallback for old versions of couchdb that don't 
               # have include_docs support
-              view = fetch_view(name, opts, &block)
+              view = fetch_view name, opts, &block
               view['rows'].collect{|r|new(database.get(r['id']))} if view['rows']
             end
           end

data/lib/couchrest/monkeypatches.rb

@@ -31,19 +31,13 @@ if RUBY_VERSION.to_f < 1.9
   class Net::BufferedIO #:nodoc:
     alias :old_rbuf_fill :rbuf_fill
     def rbuf_fill
-      if @io.respond_to?(:read_nonblock)
-        begin
+      begin
+        @rbuf << @io.read_nonblock(65536)
+      rescue Errno::EWOULDBLOCK
+        if IO.select([@io], nil, nil, @read_timeout)
           @rbuf << @io.read_nonblock(65536)
-        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)
+        else
+          raise Timeout::TimeoutError
         end
       end
     end
@@ -62,58 +56,47 @@ module RestClient
     :url => url,
     :headers => headers)
   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
   
+  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
 end

data/lib/couchrest/more/extended_document.rb

@@ -1,5 +1,4 @@
 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."
@@ -18,24 +17,18 @@ module CouchRest
     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
+    def initialize(keys={})
       super
+      apply_defaults # defined in CouchRest::Mixins::Properties
       cast_keys      # defined in CouchRest::Mixins::Properties
       unless self['_id'] && self['_rev']
         self['couchrest-type'] = self.class.to_s
@@ -79,16 +72,6 @@ module CouchRest
       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
@@ -104,7 +87,7 @@ module CouchRest
     # 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}=")
+        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)
@@ -122,62 +105,12 @@ module CouchRest
     # 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)
+        _run_save_callbacks do
+          save_without_callbacks(bulk)
         end
       end
     end
@@ -191,7 +124,7 @@ module CouchRest
       result["ok"] == true
     end
     
-    # Saves the document to the db using save. Raises an exception
+    # 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
@@ -200,10 +133,10 @@ module CouchRest
     # 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)
+    def destroy
       caught = catch(:halt)  do
         _run_destroy_callbacks do
-          result = database.delete_doc(self, bulk)
+          result = database.delete_doc self
           if result['ok']
             self['_rev'] = nil
             self['_id'] = nil

data/lib/couchrest/more/property.rb

@@ -7,24 +7,13 @@ module CouchRest
     # attribute to define
     def initialize(name, type = nil, options = {})
       @name = name.to_s
-      parse_type(type)
+      @type = type.nil? ? 'String' : type.to_s
       parse_options(options)
       self
     end
     
     
     private
-    
-      def parse_type(type)
-        if type.nil?
-          @type = 'String'
-        elsif type.is_a?(Array) && type.empty?
-          @type = 'Array'
-        else
-          @type = type.is_a?(Array) ? [type.first.to_s] : type.to_s
-        end
-      end
-      
       def parse_options(options)
         return if options.empty?
         @validation_format  = options.delete(:format)     if options[:format]