oz-couchrest 0.29

data/lib/couchrest/mixins/views.rb

@@ -0,0 +1,211 @@
+module CouchRest
+  module Mixins
+    module Views
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      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.
+        #  
+        # Calling with :database => [instance of CouchRest::Database] will
+        # send the query to a specific database, otherwise it will go to
+        # the model's default database (use_database)
+        #  
+        # 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 completely,
+        # it is recommended that you read the RSpec file at
+        # <tt>spec/core/model_spec.rb</tt>.
+
+        def view_by(*keys)
+          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
+
+        # FIXME
+        #   Define search view
+        def search_by(*keys)
+          self.refresh_design_doc
+          self.design_doc.search_by(*keys)
+        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
+
+        # returns stored defaults if there is a search view named like this in the design doc
+        def has_search_view?(view)
+          view = view.to_s.sub(/^search_/, '')
+          design_doc && design_doc['fulltext'] && design_doc['fulltext'][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]        
+          db = query.delete(:database) || database
+          raw = query.delete(:raw)
+          fetch_view_with_docs(db, name, query, raw, &block)
+        end
+
+        # Dispatch to a named search view
+        def search_view(name, query="", opts={}, &block)
+          name = name.to_s.sub(/^search_/, '')
+          db = opts.delete(:database) || database
+          opts[:q] = query
+          fetch_search_view_with_docs(db, name, opts, &block)
+        end
+
+        # DEPRECATED
+        # user model_design_doc to retrieve the current design doc
+        def all_design_doc_versions(db = database)
+          db.documents :startkey => "_design/#{self.to_s}", 
+            :endkey => "_design/#{self.to_s}-\u9999"
+        end
+        
+        def model_design_doc(db = database)
+          begin
+            @model_design_doc = db.get("_design/#{self.to_s}")
+          rescue
+            nil
+          end
+        end
+
+        # Deletes the current design doc for the current class.
+        # Running it to early could mean that live code has to regenerate
+        # potentially large indexes.
+        def cleanup_design_docs!(db = database)
+          save_design_doc_on(db)
+          # db.refresh_design_doc
+          #           db.save_design_doc
+          # design_doc = model_design_doc(db)
+          # if design_doc
+          #   db.delete_doc(design_doc)
+          # else
+          #   false
+          # end
+        end
+
+        private
+
+        def fetch_search_view_with_docs(db, name, opts, &block)
+          #if opts.has_key?(:include_docs) && opts[:include_docs] == false
+            #fetch_search_view(db, name, opts, &block)
+          #end
+
+          # FIXME try to handle pagination with the same process as views.
+          design_doc.search_on(db, name, opts, &block)
+        end
+
+        def fetch_view_with_docs(db, name, opts, raw=false, &block)
+          if raw || (opts.has_key?(:include_docs) && opts[:include_docs] == false)
+            fetch_view(db, name, opts, &block)
+          else
+            begin
+              if block.nil?
+                collection_proxy_for(design_doc, name, opts.merge({:include_docs => true}))
+              else
+                view = fetch_view db, name, opts.merge({:include_docs => true}), &block
+                view['rows'].collect{|r|new(r['doc'])} if view['rows']
+              end
+            rescue
+              # fallback for old versions of couchdb that don't 
+              # have include_docs support
+              view = fetch_view(db, name, opts, &block)
+              view['rows'].collect{|r|new(db.get(r['id']))} if view['rows']
+            end
+          end
+        end
+
+        def fetch_view(db, view_name, opts, &block)
+          raise "A view needs a database to operate on (specify :database option, or use_database in the #{self.class} class)" unless db
+          retryable = true
+          begin
+            design_doc.view_on(db, view_name, opts, &block)
+            # the design doc may not have been saved yet on this database
+          rescue RestClient::ResourceNotFound => e
+            if retryable
+              save_design_doc_on(db)
+              retryable = false
+              retry
+            else
+              raise e
+            end
+          end
+        end
+        
+      end # module ClassMethods
+      
+      
+    end
+  end
+end

data/lib/couchrest/monkeypatches.rb

@@ -0,0 +1,112 @@
+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
+  # 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)
+    u = self.getutc
+    %("#{u.strftime("%Y/%m/%d %H:%M:%S +0000")}")
+  end
+
+  # 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)
+  # rescue
+  #   fallback
+  # end
+end
+
+# Monkey patch for faster net/http io
+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
+          @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)
+        end
+      end
+    end
+  end
+end
+
+module RestClient
+  def self.copy(url, headers={})
+    Request.execute(:method => :copy,
+      :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'
+#         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,29 @@
+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={})
+      raise StandardError unless self.is_a? Hash
+      apply_defaults # defined in CouchRest::Mixins::Properties
+      super()
+      keys.each do |k,v|
+        self[k.to_s] = v
+      end if keys
+      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,232 @@
+require 'mime/types'
+require File.join(File.dirname(__FILE__), "property")
+require File.join(File.dirname(__FILE__), '..', 'mixins', 'extended_document_mixins')
+require "enumerator"
+
+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
+    include CouchRest::Mixins::ClassProxy
+    include CouchRest::Mixins::Collection
+
+    def self.subclasses
+      @subclasses ||= []
+    end
+    
+    def self.inherited(subklass)
+      subklass.send(:include, CouchRest::Mixins::Properties)
+      subklass.class_eval <<-EOS, __FILE__, __LINE__
+        def self.inherited(subklass)
+          subklass.properties = self.properties.dup
+        end
+      EOS
+      subclasses << subklass
+    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
+      passed_keys.each do |k,v|
+        if self.respond_to?("#{k}=")
+          self.send("#{k}=", passed_keys.delete(k))
+        end
+      end if passed_keys
+      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, &block)
+      if has_view?(m)
+        query = args.shift || {}
+        view(m, query, *args, &block)
+      elsif has_search_view?(m)
+        query = args.shift || {}
+        search_view(m, query, *args, &block)
+      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