andrewtimberlake-couch_potato 0.2.8.1

data/lib/couch_potato/persistence/validation.rb

@@ -0,0 +1,18 @@
+require 'validatable'
+
+module CouchPotato
+  module Persistence
+    module Validation
+      def self.included(base)
+        base.send :include, Validatable
+        base.class_eval do
+          # Override the validate method to first run before_validation callback
+          def valid?
+            self.run_callbacks :before_validation
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/view/base_view_spec.rb

@@ -0,0 +1,24 @@
+module CouchPotato
+  module View
+    class BaseViewSpec
+      attr_reader :reduce_function, :design_document, :view_name, :view_parameters, :klass, :options
+      private :klass, :options
+
+      def initialize(klass, view_name, options, view_parameters)
+        @klass = klass
+        @design_document = klass.to_s.underscore
+        @view_name = view_name
+        @options = options
+        @view_parameters = {}
+        [:group, :include_docs, :descending, :group_level, :limit].each do |key|
+          @view_parameters[key] = options[key] if options.include?(key)
+        end
+        @view_parameters.merge!(view_parameters)
+      end
+
+      def process_results(results)
+        results
+      end
+    end
+  end
+end

data/lib/couch_potato/view/custom_view_spec.rb

@@ -0,0 +1,27 @@
+module CouchPotato
+  module View
+    # a view for custom map/reduce functions that still returns model instances
+    #
+    # example:
+    #   view :my_custom_view, :map => "function(doc) { emit(doc._id, null); }", :include_docs => true, :type => :custom, :reduce => nil
+    class CustomViewSpec < BaseViewSpec
+      def map_function
+        options[:map]
+      end
+      
+      def reduce_function
+        options[:reduce]
+      end
+      
+      def view_parameters
+        {:include_docs => options[:include_docs] || false}.merge(super)
+      end
+      
+      def process_results(results)
+        results['rows'].map do |row|
+          klass.json_create row['doc'] || row['value'].merge(:_id => row['id'])
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/view/custom_views.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/base_view_spec'
+require File.dirname(__FILE__) + '/model_view_spec'
+require File.dirname(__FILE__) + '/properties_view_spec'
+require File.dirname(__FILE__) + '/custom_view_spec'
+require File.dirname(__FILE__) + '/raw_view_spec'
+
+
+module CouchPotato
+  module View
+    module CustomViews
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        # Declare a CouchDB view, for examples on how to use see the *ViewSpec classes in CouchPotato::View
+        def views
+          @views ||= {}
+        end
+
+        def execute_view(view_name, view_parameters)
+          view_spec_class(views[view_name][:type]).new(self, view_name, views[view_name], view_parameters)
+        end
+
+        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)
+          if type && type.is_a?(Class)
+            type
+          else
+            name = type.nil? ? 'Model' : type.to_s.camelize
+            CouchPotato::View.const_get("#{name}ViewSpec")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/view/model_view_spec.rb

@@ -0,0 +1,63 @@
+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
+    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
+        "function(doc) {
+           if(doc.ruby_class && doc.ruby_class == '#{@klass.name}') {
+             emit(#{formatted_key(key)}, null);
+           }
+         }"
+      end
+      
+      def reduce_function
+        "function(key, values) {
+          return values.length;
+        }"
+      end
+      
+      def process_results(results)
+        if count?
+          results['rows'].first.try(:[], 'value') || 0
+        else
+          results['rows'].map do |row|
+            klass.json_create row['doc']
+          end
+        end
+      end
+      
+      private
+      
+      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,39 @@
+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
+        "function(doc) {
+           if(doc.ruby_class && doc.ruby_class == '#{@klass.name}') {
+             emit(#{formatted_key(key)}, #{properties_for_map(properties)});
+           }
+         }"
+      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,44 @@
+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_name, map_function, reduce_function = nil)
+        @database = couchrest_database
+        @design_document_name = design_document_name
+        @view_name = view_name
+        @map_function = map_function
+        @reduce_function = reduce_function
+      end
+
+      def query_view!(parameters = {})
+        begin
+          query_view parameters
+        rescue RestClient::ResourceNotFound# => e
+          create_view
+          retry
+        end
+      end
+
+      private
+
+      def create_view
+        design_doc = @database.get "_design/#{@design_document_name}" rescue nil
+        design_doc ||= {'views' => {}, "_id" => "_design/#{@design_document_name}"}
+        design_doc['views'][@view_name.to_s] = {
+          'map' => @map_function,
+          'reduce' => @reduce_function
+        }
+        @database.save_doc(design_doc)
+      end
+
+      def query_view(parameters)
+        @database.view view_url, parameters
+      end
+
+      def view_url
+        "#{@design_document_name}/#{@view_name}"
+      end
+
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,7 @@
+# this is for rails only
+
+require File.dirname(__FILE__) + '/../lib/couch_potato'
+
+CouchPotato::Config.database_name = YAML::load(File.read(Rails.root.to_s + '/config/couchdb.yml'))[RAILS_ENV]
+
+RAILS_DEFAULT_LOGGER.info "** couch_potato: initialized from #{__FILE__}"

data/spec/callbacks_spec.rb

@@ -0,0 +1,271 @@
+require File.dirname(__FILE__) + '/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
+    CouchPotato.database.save_document! monkey
+    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