couch_potato 0.2.12

data/lib/couch_potato/persistence/simple_property.rb

@@ -0,0 +1,83 @@
+module CouchPotato
+  module Persistence
+    class SimpleProperty  #:nodoc:
+      attr_accessor :name, :type
+      
+      def initialize(owner_clazz, name, options = {})
+        self.name = name
+        self.type = options[:type]
+        
+        define_accessors accessors_module_for(owner_clazz), name, options
+      end
+      
+      def build(object, json)
+        value = json[name.to_s] || json[name.to_sym]
+        typecast_value =  if type
+                              type.json_create value
+                            else
+                              value
+                            end
+        object.send "#{name}=", typecast_value
+      end
+      
+      def dirty?(object)
+        object.send("#{name}_changed?")
+      end
+      
+      def save(object)
+        
+      end
+      
+      def destroy(object)
+        
+      end
+      
+      def serialize(json, object)
+        json[name] = object.send name
+      end
+      
+      private
+      
+      def accessors_module_for(clazz)
+        unless clazz.const_defined?('AccessorMethods')
+          accessors_module = clazz.const_set('AccessorMethods', Module.new) 
+          clazz.send(:include, accessors_module)
+        end
+        clazz.const_get('AccessorMethods')
+      end
+      
+      def define_accessors(base, name, options)
+        base.class_eval do
+          attr_reader "#{name}_was"
+
+          define_method "#{name}" do
+            value = self.instance_variable_get("@#{name}")
+            if value.blank? && options[:default]
+              default = clone_attribute(options[:default])
+              self.instance_variable_set("@#{name}", default)
+              default
+            else
+              value
+            end
+          end
+          
+          define_method "#{name}=" do |value|
+            self.instance_variable_set("@#{name}", value)
+          end
+          
+          define_method "#{name}?" do
+            !self.send(name).nil? && !self.send(name).try(:blank?)
+          end
+          
+          define_method "#{name}_changed?" do
+            !self.instance_variable_get("@#{name}_not_changed") && self.send(name) != self.send("#{name}_was")
+          end
+          
+          define_method "#{name}_not_changed" do
+            self.instance_variable_set("@#{name}_not_changed", true)
+          end
+        end
+      end
+    end
+  end
+end

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'] || row['key'])
+        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/attachments_spec.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/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.should == {"body" => {"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,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