speedmax-couch_potato 0.2.0

data/lib/couch_potato/persistence/properties.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/simple_property'
+require File.dirname(__FILE__) + '/belongs_to_property'
+
+module CouchPotato
+  module Persistence
+    module Properties
+      def self.included(base)
+        base.extend ClassMethods
+        base.class_eval do
+          def self.properties
+            @properties ||= {}
+            @properties[self.name] ||= []
+          end
+        end
+      end
+      
+      module ClassMethods
+        def property_names
+          properties.map(&:name)
+        end
+        
+        def json_create(json)
+          instance = super
+          instance.attributes.each do |name, value|
+            instance.instance_variable_set("@#{name}_was", value)
+          end
+          instance
+        end
+        
+        def property(name, options = {})
+          clazz = options.delete(:class)
+          properties << (clazz || SimpleProperty).new(self, name, options)
+        end
+
+        def belongs_to(name)
+          property name, :class => BelongsToProperty
+        end
+
+      end
+    end
+  end
+end

data/lib/couch_potato/persistence/simple_property.rb

@@ -0,0 +1,64 @@
+module CouchPotato
+  module Persistence
+    class SimpleProperty
+      attr_accessor :name, :type
+      
+      def initialize(owner_clazz, name, options = {})
+        self.name = name
+        self.type = options[:type]
+        owner_clazz.class_eval do
+          attr_reader name, "#{name}_was"
+          
+          def initialize(attributes = {})
+            super attributes
+            attributes.each do |name, value|
+              self.instance_variable_set("@#{name}_was", value)
+            end if attributes
+          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
+      
+      def build(object, json)
+        value = json[name.to_s] || json[name.to_sym]
+        typecasted_value =  if type
+                              type.json_create value
+                            else
+                              value
+                            end
+        object.send "#{name}=", typecasted_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
+    end
+  end
+end

data/lib/couch_potato/persistence.rb

@@ -0,0 +1,57 @@
+require 'digest/md5'
+require File.dirname(__FILE__) + '/database'
+require File.dirname(__FILE__) + '/persistence/properties'
+require File.dirname(__FILE__) + '/persistence/magic_timestamps'
+require File.dirname(__FILE__) + '/persistence/callbacks'
+require File.dirname(__FILE__) + '/persistence/json'
+require File.dirname(__FILE__) + '/persistence/dirty_attributes'
+require File.dirname(__FILE__) + '/view/custom_views'
+require File.dirname(__FILE__) + '/view/view_query'
+
+
+module CouchPotato
+  module Persistence
+    
+    def self.included(base)
+      base.send :include, Properties, Callbacks, Validatable, Json, CouchPotato::View::CustomViews
+      base.send :include, DirtyAttributes
+      base.send :include, MagicTimestamps
+      base.class_eval do
+        attr_accessor :_id, :_rev, :_attachments, :_deleted
+        alias_method :id, :_id
+      end
+    end
+    
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        self.send("#{name}=", value)
+      end if attributes
+    end
+    
+    def attributes=(hash)
+      hash.each do |attribute, value|
+        self.send "#{attribute}=", value
+      end
+    end
+    
+    def attributes
+      self.class.properties.inject({}) do |res, property|
+        property.serialize(res, self)
+        res
+      end
+    end
+    
+    def new?
+      _rev.nil?
+    end
+    
+    def to_param
+      _id
+    end
+    
+    def ==(other)
+      other.class == self.class && self.to_json == other.to_json
+    end
+    
+  end    
+end

data/lib/couch_potato/view/base_view_spec.rb

@@ -0,0 +1,20 @@
+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 = options.select{|key, value| [:group, :include_docs, :descending, :group_level, :limit].include?(key.to_sym)}.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,26 @@
+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,30 @@
+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 view(view_name, options)
+          self.class.instance_eval do
+            define_method view_name do |view_parameters = {}|
+              klass = options[:type] ? options[:type].to_s.camelize : 'Model'
+              CouchPotato::View.const_get("#{klass}ViewSpec").new self, view_name, options, view_parameters
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/view/model_view_spec.rb

@@ -0,0 +1,39 @@
+module CouchPotato
+  module View
+    # a view to return model instances by searching its properties
+    # example: view :my_view, :key => :name
+    class ModelViewSpec < BaseViewSpec
+      
+      def view_parameters
+        {:include_docs => true}.merge(super)
+      end
+      
+      def map_function
+        "function(doc) {
+            emit(#{formatted_key(key)}, null);
+         }"
+      end
+      
+      def process_results(results)
+        results['rows'].map do |row|
+          klass.json_create row['doc']
+        end
+      end
+      
+      private
+      
+      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,35 @@
+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) {
+            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,21 @@
+module CouchPotato
+  # 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']}}
+  module View
+    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,45 @@
+module CouchPotato
+  module View
+
+    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/lib/couch_potato.rb

@@ -0,0 +1,37 @@
+require 'couchrest'
+require 'json'
+require 'json/add/core'
+require 'json/add/rails'
+
+require 'ostruct'
+
+require 'validatable'
+
+
+module CouchPotato
+  Config = OpenStruct.new
+  
+  def self.database
+    @@__database ||= Database.new(self.couchrest_database)
+  end
+  
+  def self.couchrest_database
+    @@__couchrest_database ||= CouchRest.database(full_url_to_database)
+  end
+  
+  def self.full_url_to_database
+    database_name = CouchPotato::Config.database_name || raise('No Database configured. Set CouchPotato::Config.database_name')
+    url = database_name
+    if url !~ /^http:\/\//
+      url = "http://localhost:5984/#{database_name}"
+    end
+    url
+  end
+end
+
+require File.dirname(__FILE__) + '/core_ext/object'
+require File.dirname(__FILE__) + '/core_ext/time'
+require File.dirname(__FILE__) + '/core_ext/date'
+require File.dirname(__FILE__) + '/core_ext/string'
+require File.dirname(__FILE__) + '/couch_potato/persistence'
+

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,245 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class CallbackRecorder
+  include CouchPotato::Persistence
+  
+  property :required_property
+  
+  validates_presence_of :required_property
+  
+  [: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
+  
+  attr_accessor :lambda_works
+  before_create lambda {|model| model.lambda_works = true}
+  
+  def callbacks
+    @callbacks ||= []
+  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'}
+    @db = CouchPotato::Database.new(couchrest_database)
+  end
+  
+  describe "successful create" do
+    before(:each) do
+       @recorder.required_property = 1
+    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_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'}
+    @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_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_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
+    @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

data/spec/create_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/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)['ruby_class'].should == 'Comment'
+    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
+