couchrest_model-radiant 1.0.0

data/lib/couchrest/model/class_proxy.rb

@@ -0,0 +1,122 @@
+module CouchRest
+  module Model
+    module ClassProxy
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+
+        # Return a proxy object which represents a model class on a
+        # chosen database instance. This allows you to DRY operations
+        # where a database is chosen dynamically.
+        #  
+        # ==== Example:
+        #  
+        #   db = CouchRest::Database.new(...)
+        #   articles = Article.on(db)
+        #
+        #   articles.all { ... }
+        #   articles.by_title { ... }
+        #
+        #   u = articles.get("someid")
+        #
+        #   u = articles.new(:title => "I like plankton")
+        #   u.save    # saved on the correct database
+
+        def on(database)
+          Proxy.new(self, database)
+        end
+      end
+
+      class Proxy #:nodoc:
+        def initialize(klass, database)
+          @klass = klass
+          @database = database
+        end
+        
+        # Base
+        
+        def new(*args)
+          doc = @klass.new(*args)
+          doc.database = @database
+          doc
+        end
+        
+        def method_missing(m, *args, &block)
+          if has_view?(m)
+            query = args.shift || {}
+            return view(m, query, *args, &block)
+          elsif m.to_s =~ /^find_(by_.+)/
+            view_name = $1
+            if has_view?(view_name)
+              return first_from_view(view_name, *args) 
+            end
+          end
+          super
+        end
+        
+        # DocumentQueries
+        
+        def all(opts = {}, &block)
+          docs = @klass.all({:database => @database}.merge(opts), &block)
+          docs.each { |doc| doc.database = @database if doc.respond_to?(:database) } if docs
+          docs
+        end
+        
+        def count(opts = {}, &block)
+          @klass.all({:database => @database, :raw => true, :limit => 0}.merge(opts), &block)['total_rows']
+        end
+        
+        def first(opts = {})
+          doc = @klass.first({:database => @database}.merge(opts))
+          doc.database = @database if doc && doc.respond_to?(:database)
+          doc
+        end
+        
+        def get(id)
+          doc = @klass.get(id, @database)
+          doc.database = @database if doc && doc.respond_to?(:database)
+          doc
+        end
+        alias :find :get
+        
+        # Views
+        
+        def has_view?(view)
+          @klass.has_view?(view)
+        end
+        
+        def view(name, query={}, &block)
+          docs = @klass.view(name, {:database => @database}.merge(query), &block)
+          docs.each { |doc| doc.database = @database if doc.respond_to?(:database) } if docs
+          docs
+        end
+        
+        def first_from_view(name, *args)
+          # add to first hash available, or add to end
+          (args.last.is_a?(Hash) ? args.last : (args << {}).last)[:database] = @database
+          doc = @klass.first_from_view(name, *args)
+          doc.database = @database if doc && doc.respond_to?(:database)
+          doc
+        end
+       
+        # DesignDoc
+        
+        def design_doc
+          @klass.design_doc
+        end
+        
+        def refresh_design_doc
+          @klass.refresh_design_doc(@database)
+        end
+        
+        def save_design_doc
+          @klass.save_design_doc(@database)
+        end
+
+      end
+    end
+  end
+end

data/lib/couchrest/model/collection.rb

@@ -0,0 +1,263 @@
+module CouchRest
+  module Model
+    module Collection
+  
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        # Creates a new class method, find_all_<collection_name>, that will
+        # execute the view specified with the design_doc and view_name 
+        # parameters, along with the specified view_options.  This method will
+        # return the results of the view as an Array of objects which are
+        # instances of the class.
+        #
+        # This method is handy for objects that do not use the view_by method
+        # to declare their views.
+        def provides_collection(collection_name, design_doc, view_name, view_options)
+          class_eval <<-END, __FILE__, __LINE__ + 1
+            def self.find_all_#{collection_name}(options = {})
+              view_options = #{view_options.inspect} || {}
+              CollectionProxy.new(options[:database] || database, "#{design_doc}", "#{view_name}", view_options.merge(options), Kernel.const_get('#{self}'))
+            end
+          END
+        end
+
+        # Fetch a group of objects from CouchDB.  Options can include:
+        #   :page - Specifies the page to load (starting at 1)
+        #   :per_page - Specifies the number of objects to load per page
+        #
+        # Defaults are used if these options are not specified.
+        def paginate(options)
+          proxy = create_collection_proxy(options)
+          proxy.paginate(options)
+        end
+
+        # Iterate over the objects in a collection, fetching them from CouchDB
+        # in groups.  Options can include:
+        #   :page - Specifies the page to load
+        #   :per_page - Specifies the number of objects to load per page
+        #
+        # Defaults are used if these options are not specified.
+        def paginated_each(options, &block)
+          search = options.delete(:search)
+          unless search == true
+            proxy = create_collection_proxy(options)
+          else
+            proxy = create_search_collection_proxy(options)
+          end
+          proxy.paginated_each(options, &block)
+        end
+
+        # Create a CollectionProxy for the specified view and options.
+        # CollectionProxy behaves just like an Array, but offers support for
+        # pagination.
+        def collection_proxy_for(design_doc, view_name, view_options = {})
+          options = view_options.merge(:design_doc => design_doc, :view_name => view_name)
+          create_collection_proxy(options)
+        end
+
+        private
+
+        def create_collection_proxy(options)
+          design_doc, view_name, view_options = parse_view_options(options)
+          CollectionProxy.new(options[:database] || database, design_doc, view_name, view_options, self)
+        end
+
+        def create_search_collection_proxy(options)
+          design_doc, search_name, search_options = parse_search_options(options)
+          CollectionProxy.new(options[:database] || database, design_doc, search_name, search_options, self, :search)
+        end
+
+        def parse_view_options(options)
+          design_doc = options.delete(:design_doc)
+          raise ArgumentError, 'design_doc is required' if design_doc.nil?
+
+          view_name = options.delete(:view_name)
+          raise ArgumentError, 'view_name is required' if view_name.nil?
+
+          default_view_options = (design_doc.class == Design && 
+              design_doc['views'][view_name.to_s] &&
+              design_doc['views'][view_name.to_s]["couchrest-defaults"]) || {}
+          view_options = default_view_options.merge(options)
+          view_options.delete(:database)
+
+          [design_doc, view_name, view_options]
+        end
+
+        def parse_search_options(options)
+          design_doc = options.delete(:design_doc)
+          raise ArgumentError, 'design_doc is required' if design_doc.nil?
+
+          search_name = options.delete(:view_name)
+          raise ArgumentError, 'search_name is required' if search_name.nil?
+
+          search_options = options.clone
+          search_options.delete(:database)
+
+          [design_doc, search_name, search_options]
+        end
+
+      end
+
+      class CollectionProxy
+        alias_method :proxy_respond_to?, :respond_to?
+        instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
+
+        DEFAULT_PAGE = 1
+        DEFAULT_PER_PAGE = 30
+        
+        # Create a new CollectionProxy to represent the specified view.  If a
+        # container class is specified, the proxy will create an object of the
+        # given type for each row that comes back from the view.  If no
+        # container class is specified, the raw results are returned.
+        #
+        # The CollectionProxy provides support for paginating over a collection
+        # via the paginate, and paginated_each methods.
+        def initialize(database, design_doc, view_name, view_options = {}, container_class = nil, query_type = :view)
+          raise ArgumentError, "database is a required parameter" if database.nil?
+
+          @database = database
+          @container_class = container_class
+          @query_type = query_type
+
+          strip_pagination_options(view_options)
+          @view_options = view_options
+
+          if design_doc.class == Design
+            @view_name = "#{design_doc.name}/#{view_name}"
+          else
+            @view_name = "#{design_doc}/#{view_name}"
+          end
+        end
+
+        # See Collection.paginate
+        def paginate(options = {})
+          page, per_page = parse_options(options)
+          results = @database.send(@query_type, @view_name, pagination_options(page, per_page))
+          remember_where_we_left_off(results, page)
+          instances = convert_to_container_array(results)
+
+          begin
+            if Kernel.const_get('WillPaginate')
+              total_rows = results['total_rows'].to_i
+              paginated = WillPaginate::Collection.create(page, per_page, total_rows) do |pager|
+                pager.replace(instances)
+              end
+              return paginated
+            end
+          rescue NameError
+            # When not using will_paginate, not much we could do about this. :x
+          end
+          return instances
+        end
+
+        # See Collection.paginated_each
+        def paginated_each(options = {}, &block)
+          page, per_page = parse_options(options)
+
+          begin
+            collection = paginate({:page => page, :per_page => per_page})
+            collection.each(&block)
+            page += 1
+          end until collection.size < per_page
+        end
+
+        def respond_to?(*args)
+          proxy_respond_to?(*args) || (load_target && @target.respond_to?(*args))
+        end
+
+        # Explicitly proxy === because the instance method removal above
+        # doesn't catch it.
+        def ===(other)
+          load_target
+          other === @target
+        end
+
+        private
+
+        def method_missing(method, *args)
+          if load_target
+            if block_given?
+              @target.send(method, *args)  { |*block_args| yield(*block_args) }
+            else
+              @target.send(method, *args)
+            end
+          end
+        end
+
+        def load_target
+          unless loaded?
+            @view_options.merge!({:include_docs => true}) if @query_type == :search
+            results = @database.send(@query_type, @view_name, @view_options)
+            @target = convert_to_container_array(results)
+          end
+          @loaded = true
+          @target
+        end
+
+        def loaded?
+          @loaded
+        end
+
+        def reload
+          reset
+          load_target
+          self unless @target.nil?
+        end
+
+        def reset
+          @loaded = false
+          @target = nil
+        end
+
+        def inspect
+          load_target
+          @target.inspect
+        end
+
+        def convert_to_container_array(results) 
+          if @container_class.nil?
+            results
+          else
+            results['rows'].collect { |row| @container_class.create_from_database(row['doc']) } unless results['rows'].nil?
+          end
+        end
+
+        def pagination_options(page, per_page)
+          view_options = @view_options.clone
+          if @query_type == :view && @last_key && @last_docid && @last_page == page - 1
+            key = view_options.delete(:key)
+            end_key = view_options[:endkey] || key
+            options = { :startkey => @last_key, :endkey => end_key, :startkey_docid => @last_docid, :limit => per_page, :skip => 1 }
+          else
+            options = { :limit => per_page, :skip => per_page * (page - 1) }
+          end
+          view_options.merge(options)
+        end
+
+        def parse_options(options)
+          page = options.delete(:page) || DEFAULT_PAGE
+          per_page = options.delete(:per_page) || DEFAULT_PER_PAGE
+          [page.to_i, per_page.to_i]
+        end
+
+        def strip_pagination_options(options)
+          parse_options(options)
+        end
+
+        def remember_where_we_left_off(results, page)
+          last_row = results['rows'].last
+          if last_row
+            @last_key = last_row['key']
+            @last_docid = last_row['id']
+          end
+          @last_page = page
+        end
+      end
+
+    end
+  end
+end

data/lib/couchrest/model/configuration.rb

@@ -0,0 +1,51 @@
+module CouchRest
+
+  # CouchRest Model Configuration support, stolen from Carrierwave by jnicklas
+  #    http://github.com/jnicklas/carrierwave/blob/master/lib/carrierwave/uploader/configuration.rb
+
+  module Model
+    module Configuration
+      extend ActiveSupport::Concern
+
+      included do
+        add_config :model_type_key
+        add_config :mass_assign_any_attribute
+        
+        configure do |config|
+          config.model_type_key = 'couchrest-type' # 'model'?
+          config.mass_assign_any_attribute = false
+        end
+      end
+
+      module ClassMethods
+
+        def add_config(name)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.#{name}(value=nil)
+              @#{name} = value if value
+              return @#{name} if self.object_id == #{self.object_id} || defined?(@#{name})
+              name = superclass.#{name}
+              return nil if name.nil? && !instance_variable_defined?("@#{name}")
+              @#{name} = name && !name.is_a?(Module) && !name.is_a?(Symbol) && !name.is_a?(Numeric) && !name.is_a?(TrueClass) && !name.is_a?(FalseClass) ? name.dup : name
+            end
+
+            def self.#{name}=(value)
+              @#{name} = value
+            end
+
+            def #{name}
+              self.class.#{name}
+            end
+          RUBY
+        end
+
+        def configure
+          yield self
+        end
+      end
+
+    end
+  end
+end
+
+

data/lib/couchrest/model/design_doc.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+module CouchRest
+  module Model
+    module DesignDoc
+      extend ActiveSupport::Concern
+      
+      module ClassMethods
+        
+        def design_doc
+          @design_doc ||= Design.new(default_design_doc)
+        end
+    
+        # Use when something has been changed, like a view, so that on the next request
+        # the design docs will be updated (if changed!)
+        def req_design_doc_refresh
+          @design_doc_fresh = { }
+        end
+        
+        def design_doc_id
+          "_design/#{design_doc_slug}"
+        end
+
+        def design_doc_slug
+          self.to_s
+        end
+
+        def default_design_doc
+          {
+            "_id" => design_doc_id,
+            "language" => "javascript",
+            "views" => {
+              'all' => {
+                'map' => "function(doc) {
+                  if (doc['#{self.model_type_key}'] == '#{self.to_s}') {
+                    emit(doc['_id'],1);
+                  }
+                }"
+              }
+            }
+          }
+        end
+
+        # DEPRECATED
+        # use stored_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
+       
+        # Retreive the latest version of the design document directly
+        # from the database.
+        def stored_design_doc(db = database)
+          db.get(design_doc_id) rescue nil
+        end
+        alias :model_design_doc :stored_design_doc
+
+        def refresh_design_doc(db = database)
+          raise "Database missing for design document refresh" if db.nil?
+          unless design_doc_fresh(db)
+            save_design_doc(db)
+            design_doc_fresh(db, true)
+          end
+        end
+
+        # Save the design doc onto a target database in a thread-safe way,
+        # not modifying the model's design_doc
+        #
+        # See also save_design_doc! to always save the design doc even if there
+        # are no changes.
+        def save_design_doc(db = database, force = false)
+          update_design_doc(Design.new(design_doc), db, force)
+        end
+
+        # Force the update of the model's design_doc even if it hasn't changed.
+        def save_design_doc!(db = database)
+          save_design_doc(db, true)
+        end
+
+        protected
+
+        def design_doc_fresh(db, fresh = nil)
+          @design_doc_fresh ||= {}
+          if fresh.nil? 
+            @design_doc_fresh[db.uri] || false
+          else
+            @design_doc_fresh[db.uri] = fresh
+          end
+        end
+
+        # Writes out a design_doc to a given database, returning the
+        # updated design doc
+        def update_design_doc(design_doc, db, force = false)
+          saved = stored_design_doc(db)
+          if saved
+            changes = force
+            design_doc['views'].each do |name, view|
+              if !compare_views(saved['views'][name], view)
+                changes = true
+                saved['views'][name] = view
+              end
+            end
+            if changes
+              db.save_doc(saved)
+            end
+            design_doc
+          else
+            design_doc.database = db
+            design_doc.save
+            design_doc
+          end
+        end
+
+        # Return true if the two views match
+        def compare_views(orig, repl)
+          return false if orig.nil? or repl.nil?
+          (orig['map'].to_s.strip == repl['map'].to_s.strip) && (orig['reduce'].to_s.strip == repl['reduce'].to_s.strip)
+        end
+
+      end # module ClassMethods
+      
+    end
+  end
+end