couch_potato-rails2 0.5.6

data/lib/couch_potato/view/custom_views.rb

@@ -0,0 +1,52 @@
+require 'couch_potato/view/base_view_spec'
+require 'couch_potato/view/model_view_spec'
+require 'couch_potato/view/properties_view_spec'
+require 'couch_potato/view/custom_view_spec'
+require 'couch_potato/view/raw_view_spec'
+
+
+module CouchPotato
+  module View
+    module CustomViews
+
+      def self.included(base) #:nodoc:
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def views(view_name = nil) #:nodoc:
+          if view_name
+            _find_view(view_name)
+          else
+            @views ||= {}
+          end
+        end
+
+        def execute_view(view_name, view_parameters) #:nodoc:
+          view_spec_class(views(view_name)[:type]).new(self, view_name, views(view_name), view_parameters)
+        end
+        
+        # Declare a CouchDB view, for examples on how to use see the *ViewSpec classes in CouchPotato::View
+        def view(view_name, options)
+          view_name = view_name.to_s
+          views[view_name] = options
+          method_str = "def #{view_name}(view_parameters = {}); execute_view(\"#{view_name}\", view_parameters); end"
+          self.instance_eval(method_str)
+        end
+
+        def view_spec_class(type) #:nodoc:
+          if type && type.is_a?(Class)
+            type
+          else
+            name = type.nil? ? 'Model' : type.to_s.camelize
+            CouchPotato::View.const_get("#{name}ViewSpec")
+          end
+        end
+        
+        def _find_view(view) #:nodoc:
+          (@views && @views[view]) || (superclass._find_view(view) if superclass.respond_to?(:_find_view))
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/view/lists.rb

@@ -0,0 +1,23 @@
+module CouchPotato
+  module View
+    module Lists
+      def self.included(base)
+        base.send :extend, ClassMethods
+      end
+      
+      module ClassMethods
+        def list(name, function)
+          lists[name] = function
+        end
+        
+        def lists(name = nil)
+          if name.nil?
+            @lists ||= {}
+          else
+            (@lists && @lists[name]) || (superclass.lists(name) if superclass.respond_to?(:lists))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/view/model_view_spec.rb

@@ -0,0 +1,75 @@
+module CouchPotato
+  module View
+    # A view to return model instances by searching its properties.
+    # If you pass reduce => true will count instead
+    #
+    # example:
+    #   view :my_view, :key => :name
+    # 
+    # in addition you can pass in conditions as a javascript string
+    #   view :my_view_only_completed, :key => :name, :conditions => 'doc.completed = true'
+    class ModelViewSpec < BaseViewSpec
+      
+      def view_parameters
+        _super = super
+        if _super[:reduce]
+          _super
+        else
+          {:include_docs => true, :reduce => false}.merge(_super)
+        end
+      end
+      
+      def map_function
+        map_body do
+          "emit(#{formatted_key(key)}, 1);"
+        end
+      end
+      
+      def reduce_function
+        "function(key, values) {
+          return sum(values);
+        }"
+      end
+      
+      def process_results(results)
+        if count?
+          results['rows'].first.try(:[], 'value') || 0
+        else
+          results['rows'].map { |row| row['doc'] || row['id'] }
+        end
+      end
+      
+      private
+      
+      def map_body(&block)
+        "function(doc) {
+           if(doc.#{JSON.create_id} && doc.#{JSON.create_id} == '#{@klass.name}'#{conditions_js}) {
+             " + yield + "
+           }
+         }"
+        
+      end
+      
+      def conditions_js
+        " && (#{options[:conditions]})" if options[:conditions]
+      end
+      
+      def count?
+        view_parameters[:reduce]
+      end
+      
+      def key
+        options[:key]
+      end
+      
+      def formatted_key(key)
+        if key.is_a? Array
+          '[' + key.map{|attribute| formatted_key(attribute)}.join(', ') + ']'
+        else
+          "doc['#{key}']"
+        end
+      end
+      
+    end
+  end
+end

data/lib/couch_potato/view/properties_view_spec.rb

@@ -0,0 +1,47 @@
+module CouchPotato
+  module View
+    # A view to return model instances with only some properties poulated by searching its properties, e.g. for very large documents where you are only interested in some of their data
+    #
+    # example:
+    #   view :my_view, :key => :name, :properties => [:name, :author], :type => :properties
+    class PropertiesViewSpec < ModelViewSpec
+      def map_function
+        map_body do
+          "emit(#{formatted_key(key)}, #{properties_for_map(properties)});"
+        end
+      end
+      
+      def reduce_function
+        <<-JS
+          function(key, values, rereduce) {
+            if(rereduce) {
+              return sum(values);
+            } else {
+              return values.length;
+            }
+          }
+        JS
+      end
+      
+      def process_results(results)
+        results['rows'].map do |row|
+          klass.json_create row['value'].merge(:_id => row['id'])
+        end
+      end
+      
+      def view_parameters
+        {:include_docs => false}.merge(super)
+      end
+      
+      private
+      
+      def properties
+        options[:properties]
+      end
+      
+      def properties_for_map(properties)
+        '{' + properties.map{|p| "#{p}: doc.#{p}"}.join(', ') + '}'
+      end
+    end
+  end
+end

data/lib/couch_potato/view/raw_view_spec.rb

@@ -0,0 +1,25 @@
+module CouchPotato
+  module View
+    # A view for custom map/reduce functions that returns the raw data fromcouchdb
+    #
+    # example:
+    #   view :my_custom_view, :map => "function(doc) { emit(doc._id, null); }", :type => :raw, :reduce => nil
+    # optionally you can pass in a results filter which you can use to process the raw couchdb results before returning them
+    #
+    # example:
+    #   view :my_custom_view, :map => "function(doc) { emit(doc._id, null); }", :type => :raw, :results_filter => lambda{|results| results['rows].map{|row| row['value']}}
+    class RawViewSpec < BaseViewSpec
+      def map_function
+        options[:map]
+      end
+      
+      def process_results(results)
+        options[:results_filter] ? options[:results_filter].call(results) : results
+      end
+      
+      def reduce_function
+        options[:reduce]
+      end
+    end
+  end
+end

data/lib/couch_potato/view/view_query.rb

@@ -0,0 +1,82 @@
+module CouchPotato
+  module View
+    # Used to query views (and create them if they don't exist). Usually you won't have to use this class directly. Instead it is used internally by the CouchPotato::Database.view method.
+    class ViewQuery
+      def initialize(couchrest_database, design_document_name, view, list = nil)
+        @database = couchrest_database
+        @design_document_name = design_document_name
+        @view_name = view.keys[0]
+        @map_function = view.values[0][:map]
+        @reduce_function = view.values[0][:reduce]
+        if list
+          @list_function = list.values[0]
+          @list_name = list.keys[0]
+        end
+      end
+
+      def query_view!(parameters = {})
+        update_view unless view_has_been_updated?
+        begin
+          query_view parameters
+        rescue RestClient::ResourceNotFound
+          update_view
+          retry
+        end
+      end
+
+      private
+
+      def update_view
+        design_doc = @database.get "_design/#{@design_document_name}" rescue nil
+        original_views = design_doc && design_doc['views'].dup
+        original_lists = design_doc && design_doc['lists'] && design_doc['lists'].dup
+        view_updated unless design_doc.nil?
+        design_doc ||= empty_design_document
+        design_doc['views'][@view_name.to_s] = view_functions
+        if @list_function
+          design_doc['lists'] ||= {}
+          design_doc['lists'][@list_name.to_s] = @list_function 
+        end
+        @database.save_doc(design_doc) if original_views != design_doc['views'] || original_lists != design_doc['lists']
+      end
+      
+      def view_functions
+        if @reduce_function
+          {'map' => @map_function, 'reduce' => @reduce_function}
+        else
+          {'map' => @map_function}
+        end
+      end
+      
+      def empty_design_document
+        {'views' => {}, 'lists' => {}, "_id" => "_design/#{@design_document_name}", "language" => "javascript"}
+      end
+      
+      def view_has_been_updated?
+        updated_views[[@design_document_name, @view_name]]
+      end
+      
+      def view_updated
+        updated_views[[@design_document_name, @view_name]] = true
+      end
+      
+      def updated_views
+        @@updated_views ||= {}
+        @@updated_views
+      end
+
+      def query_view(parameters)
+        if @list_name
+          CouchRest.get CouchRest.paramify_url(CouchPotato.full_url_to_database + "/_design/#{@design_document_name}/_list/#{@list_name}/#{@view_name}", parameters)
+        else
+          @database.view view_url, parameters
+        end
+      end
+
+      def view_url
+        "#{@design_document_name}/#{@view_name}"
+      end
+
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,4 @@
+# this is for rails only
+
+require File.expand_path(File.dirname(__FILE__) + '/../lib/couch_potato')
+Rails.logger.info "** couch_potato: initialized from #{__FILE__}"

data/rails/reload_classes.rb

@@ -0,0 +1,47 @@
+module CouchPotato
+  
+  module ClassReloading
+    private
+    
+    def with_class_reloading(&block)
+      begin
+        yield
+      rescue ArgumentError => e
+        if(name = e.message.scan(/(can't find const|undefined class\/module) ([\w\:]+)/).try(:first).try(:[], 1))
+          eval name.gsub(/\:+$/, '')
+          retry
+        else
+          raise e
+        end
+      end
+    end
+  end
+  
+  View::ViewQuery.class_eval do
+    include ClassReloading
+
+    def query_view_with_class_reloading(*args)
+      with_class_reloading do
+        query_view_without_class_reloading(*args)
+      end
+    end
+
+    alias_method :query_view_without_class_reloading, :query_view
+    alias_method :query_view, :query_view_with_class_reloading
+  end
+  
+  Database.class_eval do
+    include ClassReloading
+
+    def load_document_with_class_reloading(*args)
+      with_class_reloading do
+        load_document_without_class_reloading *args
+      end
+    end
+
+    alias_method :load_document_without_class_reloading, :load_document
+    alias_method :load_document, :load_document_with_class_reloading
+    alias_method :load, :load_document
+  end
+end
+

data/spec/attachments_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe CouchPotato, 'attachments' do
+  it "should persist an attachment" do
+    comment = Comment.new :title => 'nil'
+    comment._attachments['body'] = {'data' => 'a useful comment', 'content_type' => 'text/plain'}
+    CouchPotato.database.save! comment
+    CouchPotato.couchrest_database.fetch_attachment(comment.to_hash, 'body').to_s.should == 'a useful comment'
+  end
+  
+  it "should give me information about the attachments of a document" do
+    comment = Comment.new :title => 'nil'
+    comment._attachments = {'body' => {'data' => 'a useful comment', 'content_type' => 'text/plain'}}
+    CouchPotato.database.save! comment
+    comment_reloaded = CouchPotato.database.load comment.id
+    comment_reloaded._attachments["body"].should include({"content_type" => "text/plain", "stub" => true, "length" => 16})
+  end
+  
+  it "should have an empty array for a new object" do
+    Comment.new._attachments.should == {}
+  end
+  
+end

data/spec/callbacks_spec.rb

@@ -0,0 +1,297 @@
+require 'spec_helper'
+
+class CallbackRecorder
+  include CouchPotato::Persistence
+  
+  property :required_property
+  
+  validates_presence_of :required_property
+  
+  [:before_validation, :before_validation_on_create,
+    :before_validation_on_save, :before_validation_on_update, 
+    :before_save, :before_create, :before_create,
+    :after_save, :after_create, :after_create,
+    :before_update, :after_update,
+    :before_destroy, :after_destroy
+  ].each do |callback|
+    define_method callback do
+      callbacks << callback
+    end
+    self.send callback, callback
+  end
+  
+  view :all, :key  => :required_property
+  
+  def callbacks
+    @callbacks ||= []
+  end
+  
+  private
+  
+  def method_callback_with_argument(db)
+    db.view CallbackRecorder.all
+  end
+  
+end
+
+describe "multiple callbacks at once" do
+
+  class Monkey
+    include CouchPotato::Persistence
+    attr_accessor :eaten_banana, :eaten_apple
+    
+    before_create :eat_apple, :eat_banana
+    
+    private
+    
+    def eat_banana
+      self.eaten_banana = true
+    end
+    
+    def eat_apple
+      self.eaten_apple = true
+    end
+  end
+  
+  it "should run all callback methods given to the callback method call" do
+    monkey = Monkey.new
+    monkey.run_callbacks :create
+    monkey.eaten_banana.should be_true
+    monkey.eaten_apple.should be_true
+  end
+end
+
+describe 'create callbacks' do
+  
+  before(:each) do
+    @recorder = CallbackRecorder.new
+    couchrest_database = stub 'couchrest_database', :save_doc => {'id' => '1', 'rev' => '2'}, :view => {'rows' => []}, :info => nil
+    @db = CouchPotato::Database.new(couchrest_database)
+  end
+  
+  describe "successful create" do
+    before(:each) do
+       @recorder.required_property = 1
+    end
+    
+    it "should call before_validation" do
+      @recorder.valid?
+      @recorder.callbacks.should include(:before_validation)
+    end
+        
+    it "should call before_validation_on_create" do
+      @db.save_document! @recorder
+      @recorder.callbacks.should include(:before_validation_on_create)
+    end
+    
+    it "should call before_validation_on_save" do
+      @db.save_document! @recorder
+      @recorder.callbacks.should include(:before_validation_on_save)
+    end
+    
+    it "should call before_save" do
+      @db.save_document! @recorder
+      @recorder.callbacks.should include(:before_save)
+    end
+    
+    it "should call after_save" do
+      @db.save_document! @recorder
+      @recorder.callbacks.should include(:after_save)
+    end
+    
+    it "should call before_create" do
+      @db.save_document! @recorder
+      @recorder.callbacks.should include(:before_create)
+    end
+    
+    it "should call after_create" do
+      @db.save_document! @recorder
+      @recorder.callbacks.should include(:after_create)
+    end
+    
+  end
+  
+  describe "failed create" do
+    
+    it "should call before_validation" do
+      @recorder.valid?
+      @recorder.callbacks.should include(:before_validation)
+    end
+    
+    it "should call before_validation_on_create" do
+      @db.save_document @recorder
+      @recorder.callbacks.should include(:before_validation_on_create)
+    end
+    
+    it "should call before_validation_on_save" do
+      @db.save_document @recorder
+      @recorder.callbacks.should include(:before_validation_on_save)
+    end
+    
+    it "should not call before_save" do
+      @db.save_document @recorder
+      @recorder.callbacks.should_not include(:before_save)
+    end
+    
+    it "should not call after_save" do
+      @db.save_document @recorder
+      @recorder.callbacks.should_not include(:after_save)
+    end
+    
+    it "should not call before_create" do
+      @db.save_document @recorder
+      @recorder.callbacks.should_not include(:before_create)
+    end
+    
+    it "should not call after_create" do
+      @db.save_document @recorder
+      @recorder.callbacks.should_not include(:after_create)
+    end
+  end
+end
+
+describe "update callbacks" do
+  
+  before(:each) do
+    @recorder = CallbackRecorder.new :required_property => 1
+    
+    couchrest_database = stub 'couchrest_database', :save_doc => {'id' => '1', 'rev' => '2'}, :view => {'rows' => []}, :info => nil
+    @db = CouchPotato::Database.new(couchrest_database)
+    @db.save_document! @recorder
+    
+    @recorder.required_property = 2
+    @recorder.callbacks.clear
+  end
+  
+  describe "successful update" do
+    
+    before(:each) do
+      @db.save_document! @recorder
+    end
+    
+    it "should call before_validation" do
+      @recorder.callbacks.should include(:before_validation)
+    end
+    
+    it "should call before_validation_on_update" do
+      @recorder.callbacks.should include(:before_validation_on_update)
+    end
+    
+    it "should call before_validation_on_save" do
+      @recorder.callbacks.should include(:before_validation_on_save)
+    end
+    
+    it "should call before_save" do
+      @recorder.callbacks.should include(:before_save)
+    end
+    
+    it "should call after_save" do
+      @recorder.callbacks.should include(:after_save)
+    end
+    
+    it "should call before_update" do
+      @recorder.callbacks.should include(:before_update)
+    end
+    
+    it "should call after_update" do
+      @recorder.callbacks.should include(:after_update)
+    end
+    
+  end
+  
+  describe "failed update" do
+    
+    before(:each) do
+       @recorder.required_property = nil
+       @db.save_document @recorder
+    end
+    
+    it "should call before_validation" do
+      @recorder.callbacks.should include(:before_validation)
+    end
+    
+    it "should call before_validation_on_update" do
+      @recorder.callbacks.should include(:before_validation_on_update)
+    end
+    
+    it "should call before_validation_on_save" do
+      @recorder.callbacks.should include(:before_validation_on_save)
+    end
+    
+    it "should not call before_save" do
+      @recorder.callbacks.should_not include(:before_save)
+    end
+    
+    it "should not call after_save" do
+      @recorder.callbacks.should_not include(:after_save)
+    end
+    
+    it "should not call before_update" do
+      @recorder.callbacks.should_not include(:before_update)
+    end
+    
+    it "should not call after_update" do
+      @recorder.callbacks.should_not include(:after_update)
+    end
+    
+  end
+  
+end
+
+describe "destroy callbacks" do
+  
+  before(:each) do
+    @recorder = CallbackRecorder.new :required_property => 1
+    couchrest_database = stub 'couchrest_database', :save_doc => {'id' => '1', 'rev' => '2'}, :delete_doc => nil, :view => {'rows' => []}, :info => nil
+    @db = CouchPotato::Database.new(couchrest_database)
+    @db.save_document! @recorder
+    
+    @recorder.callbacks.clear
+  end
+  
+  it "should call before_destroy" do
+    @db.destroy_document @recorder
+    @recorder.callbacks.should include(:before_destroy)
+  end
+  
+  it "should call after_destroy" do
+    @db.destroy_document @recorder
+    @recorder.callbacks.should include(:after_destroy)
+  end
+end
+
+describe "validation callbacks" do
+  class ValidatedUser
+    include CouchPotato::Persistence
+
+    property :name
+    before_validation :check_name
+    validates_presence_of :name
+
+    def check_name
+      errors.add(:name, 'should be Paul') unless name == "Paul"
+    end
+  end
+
+  it "should keep error messages set in custom before_validation filters" do
+    user = ValidatedUser.new(:name => "john")
+    user.valid?.should == false
+    user.errors.on(:name).should == "should be Paul"
+  end
+
+  it "should combine the errors from validations and callbacks" do
+    user = ValidatedUser.new(:name => nil)
+    user.valid?.should == false
+    user.errors.on(:name).any? {|msg| msg =~ /can't be (empty|blank)/ }.should == true
+    user.errors.on(:name).any? {|msg| msg == "should be Paul" }.should == true
+    user.errors.on(:name).size.should == 2
+  end
+
+  it "should clear the errors on subsequent calls to valid?" do
+    user = ValidatedUser.new(:name => nil)
+    user.valid?.should == false
+    user.name = 'Paul'
+    user.valid?.should == true
+    user.errors.on(:name).should == nil
+  end
+end