davber_couch_potato 0.3.0

data/lib/couch_potato/view/view_query.rb

@@ -0,0 +1,78 @@
+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
+        {'map' => @map_function, 'reduce' => @reduce_function}
+      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/lib/couch_potato.rb

@@ -0,0 +1,79 @@
+require 'couchrest'
+require 'json'
+require 'json/add/core'
+require 'json/add/rails'
+
+require 'ostruct'
+
+unless defined?(CouchPotato)
+  module CouchPotato
+    DEFAULT_TYPE_FIELD = 'ruby_class'
+
+    # The name of the type field of CouchDB documents
+    @@type_field = DEFAULT_TYPE_FIELD
+    # The function mapping classes to the corresponding CouchDB design document.
+    @@design_name_fun = lambda do |klass|
+      klass_name = klass.to_s
+      klass_name.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      klass_name.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      klass_name.tr!("-", "_")
+      klass_name.downcase
+    end
+
+    # Get the type field name to use.
+    # NOTE: this is universal, so will transcend individual databases
+    def self.type_field
+      @@type_field
+    end
+
+    def self.type_field= type_field
+      @@type_field = type_field
+    end
+
+    # Get the lambda to use for conversion from a class to the design document name
+    def self.design_name_fun
+      @@design_name_fun
+    end
+
+    def self.design_name_fun= fun
+      @@design_name_fun = fun
+    end
+
+    Config = Struct.new(:database_name, :validation_framework).new
+    Config.validation_framework = :validatable # default to the validatable gem for validations
+
+    # Returns a database instance which you can then use to create objects and query views. You have to set the CouchPotato::Config.database_name before this works.
+    def self.database
+      @@__database ||= Database.new(self.couchrest_database)
+    end
+
+    # Returns the underlying CouchRest database object if you want low level access to your CouchDB. You have to set the CouchPotato::Config.database_name before this works.
+    def self.couchrest_database
+      @@__couchrest_database ||= CouchRest.database(full_url_to_database)
+    end
+
+    private
+
+    def self.full_url_to_database
+      raise('No Database configured. Set CouchPotato::Config.database_name') unless CouchPotato::Config.database_name
+      if CouchPotato::Config.database_name.match(%r{https?://})
+        CouchPotato::Config.database_name
+      else
+        "http://127.0.0.1:5984/#{CouchPotato::Config.database_name}"
+      end
+    end
+  end
+end
+
+JSON.create_id = CouchPotato.type_field
+
+$LOAD_PATH << File.dirname(__FILE__)
+
+require 'core_ext/object'
+require 'core_ext/time'
+require 'core_ext/date'
+require 'core_ext/string'
+require 'core_ext/symbol'
+require 'couch_potato/validation'
+require 'couch_potato/persistence'
+require 'couch_potato/railtie' if defined?(Rails)

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\:]+)/).first[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,308 @@
+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
+  
+  attr_accessor :lambda_works
+  before_create lambda {|model| model.lambda_works = true }
+  
+  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 :before_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 "lambda callbacks" do
+  it "should run the lambda" do
+    recorder = CallbackRecorder.new
+    recorder.run_callbacks :before_create
+    recorder.lambda_works.should be_true
+  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

data/spec/create_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe "create" do
+  before(:all) do
+    recreate_db
+  end
+  describe "succeeds" do
+    it "should store the class" do
+      @comment = Comment.new :title => 'my_title'
+      CouchPotato.database.save_document! @comment
+      CouchPotato.couchrest_database.get(@comment.id).send(JSON.create_id).should == 'Comment'
+    end
+    
+    it "should persist a given created_at" do
+      @comment = Comment.new :created_at => Time.parse('2010-01-02 12:34:48 +0000'), :title => '-'
+      CouchPotato.database.save_document! @comment
+      CouchPotato.couchrest_database.get(@comment.id).created_at.should == Time.parse('2010-01-02 12:34:48 +0000')
+    end
+    
+    it "should persist a given updated_at" do
+      @comment = Comment.new :updated_at => Time.parse('2010-01-02 12:34:48 +0000'), :title => '-'
+      CouchPotato.database.save_document! @comment
+      CouchPotato.couchrest_database.get(@comment.id).updated_at.should == Time.parse('2010-01-02 12:34:48 +0000')
+    end
+  end
+  describe "fails" do
+    it "should not store anything" do
+      @comment = Comment.new
+      CouchPotato.database.save_document @comment
+      CouchPotato.couchrest_database.documents['rows'].should be_empty
+    end
+  end
+end
+