langalex-couch_potato 0.1

data/lib/couch_potato/persistence/inline_has_many_property.rb

@@ -0,0 +1,39 @@
+class InlineHasManyProperty
+  attr_accessor :name
+  
+  def initialize(owner_clazz, name, options = {})
+    @name = name
+    getter =  <<-GETTER
+      def #{name}
+        @#{name} ||= CouchPotato::Persistence::InlineCollection.new(#{item_class_name})
+      end
+    GETTER
+    owner_clazz.class_eval getter
+  end
+  
+  def build(object, json)
+    object.send("#{name}").clear
+    json[name.to_s].each do |item|
+      item.delete 'ruby_class'
+      object.send("#{name}").build item
+    end
+  end
+  
+  def save(object)
+    
+  end
+  
+  def serialize(json, object)
+    json[name.to_s] = object.send(name)
+  end
+  
+  def destroy(object)
+    
+  end
+  
+  private
+  
+  def item_class_name
+    @name.to_s.singularize.camelcase
+  end
+end

data/lib/couch_potato/persistence/json.rb

@@ -0,0 +1,46 @@
+module CouchPotato
+  module Persistence
+    module Json
+      def self.included(base)
+        base.extend ClassMethods
+      end
+      
+      def to_json(*args)
+        (self.class.properties).inject({}) do |props, property|
+          property.serialize(props, self)
+          props
+        end.merge('ruby_class' => self.class.name).merge(id_and_rev_json).merge(timestamps_json).to_json(*args)
+      end
+      
+      private
+      
+      def id_and_rev_json
+        [:_id, :_rev, :_deleted].inject({}) do |hash, key|
+          hash[key] = self.send(key) unless self.send(key).nil?
+          hash
+        end
+      end
+      
+      def timestamps_json
+        [:created_at, :updated_at].inject({}) do |hash, key|
+          hash[key] = self.send(key).to_s unless self.send(key).nil?
+          hash
+        end
+      end
+      
+      module ClassMethods
+        def json_create(json)
+          instance = self.new
+          instance.created_at = Time.parse(json['created_at']) 
+          instance.updated_at = Time.parse(json['updated_at'])
+          instance._id = json['_id']
+          instance._rev = json['_rev']
+          properties.each do |property|
+            property.build(instance, json)
+          end
+          instance
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/persistence/properties.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/simple_property'
+require File.dirname(__FILE__) + '/belongs_to_property'
+require File.dirname(__FILE__) + '/inline_has_many_property'
+require File.dirname(__FILE__) + '/external_has_many_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 property(name, options = {})
+          clazz = options.delete(:class)
+          properties << (clazz || SimpleProperty).new(self, name, options)
+        end
+
+        def belongs_to(name)
+          property name, :class => BelongsToProperty
+        end
+
+        def has_many(name, options = {})
+          stored = options.delete(:stored)
+          property name, options.merge(:class => (stored == :inline ? InlineHasManyProperty : ExternalHasManyProperty))
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/persistence/simple_property.rb

@@ -0,0 +1,33 @@
+module CouchPotato
+  module Persistence
+    class SimpleProperty
+      attr_accessor :name
+      
+      def initialize(owner_clazz, name, options = {})
+        self.name = name
+        owner_clazz.class_eval do
+          attr_accessor name
+          define_method "#{name}?" do
+            !self.send(name).nil? && !self.send(name).try(:blank?)
+          end
+        end
+      end
+      
+      def build(object, json)
+        object.send "#{name}=", json.stringify_keys[name.to_s]
+      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,186 @@
+require 'digest/md5'
+require 'couchrest'
+require 'validatable'
+require File.dirname(__FILE__) + '/persistence/inline_collection'
+require File.dirname(__FILE__) + '/persistence/external_collection'
+require File.dirname(__FILE__) + '/persistence/properties'
+require File.dirname(__FILE__) + '/persistence/callbacks'
+require File.dirname(__FILE__) + '/persistence/json'
+require File.dirname(__FILE__) + '/persistence/bulk_save_queue'
+require File.dirname(__FILE__) + '/persistence/find'
+
+module CouchPotato
+  module Persistence
+    
+    class ValidationsFailedError < ::Exception; end
+    class UnsavedRecordError < ::Exception; end
+    
+    def self.included(base)
+      base.send :extend, ClassMethods, Find
+      base.send :include, Callbacks, Properties, Validatable, Json
+      base.class_eval do
+        attr_accessor :_id, :_rev, :_attachments, :_deleted, :created_at, :updated_at
+        attr_reader :bulk_save_queue
+        alias_method :id, :_id
+      end
+    end
+    
+    def initialize(attributes = {})
+      @bulk_save_queue = BulkSaveQueue.new
+      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 save!
+      save || raise(ValidationsFailedError.new(self.errors.full_messages))
+    end
+    
+    def save
+      if new_document?
+        create_document 
+      else
+        update_document
+      end
+    end
+    
+    def destroy
+      run_callbacks(:before_destroy)
+      self._deleted = true
+      bulk_save_queue << self
+      destroy_dependent_objects
+      bulk_save_queue.save do |res|
+        self._id = nil
+        self._rev = nil
+      end
+      run_callbacks(:after_destroy)
+    end
+
+    def reload
+      raise(UnsavedRecordError.new) unless _id
+      json = self.class.db.get _id
+      self.class.properties.each do |property|
+        property.build self, json
+      end
+    end
+    
+    def new_document?
+      _id.nil?
+    end
+    
+    def to_param
+      _id
+    end
+    
+    def [](name)
+      self.send name
+    end
+    
+    def ==(other)
+      other.class == self.class && self.class.property_names.map{|name| self.send(name)} == self.class.property_names.map{|name| other.send(name)}
+    end
+    
+    private
+    
+    def create_document
+      run_callbacks :before_validation_on_save
+      run_callbacks :before_validation_on_create
+      return unless valid?
+      run_callbacks :before_save
+      run_callbacks :before_create
+      self.created_at = Time.now
+      self.updated_at = Time.now
+      self._id = self.class.db.server.next_uuid rescue Digest::MD5.hexdigest(rand(1000000000000).to_s) # only works with couchdb 0.9
+      bulk_save_queue << self
+      save_dependent_objects
+      bulk_save_queue.save do |res|
+        self._rev = extract_rev(res)
+      end
+      run_callbacks :after_save
+      run_callbacks :after_create
+      true
+    end
+    
+    def extract_rev(res)
+      res['new_revs'].select{|hash| hash['id'] == self.id}.first['rev']
+    end
+    
+    def update_document
+      run_callbacks(:before_validation_on_save)
+      run_callbacks(:before_validation_on_update)
+      return unless valid?
+      run_callbacks :before_save
+      run_callbacks :before_update
+      self.updated_at = Time.now
+      bulk_save_queue << self
+      save_dependent_objects
+      bulk_save_queue.save do |res|
+        self._rev = extract_rev(res)
+      end
+      run_callbacks :after_save
+      run_callbacks :after_update
+      true
+    end
+    
+    def save_dependent_objects
+      self.class.properties.each do |property|
+        property.save(self)
+      end
+    end
+    
+    def destroy_dependent_objects
+      self.class.properties.each do |property|
+        property.destroy(self)
+      end
+    end
+    
+    module ClassMethods
+      
+      def create!(attributes = {})
+        instance = self.new attributes
+        instance.save!
+        instance
+      end
+      
+      def create(attributes = {})
+        instance = self.new attributes
+        instance.save
+        instance
+      end
+      
+      def get(id)
+        begin
+          self.json_create db.get(id)
+        rescue(RestClient::ResourceNotFound)
+          nil
+        end
+      end
+      
+      def db(name = nil)
+        ::CouchPotato::Persistence.Db(name)
+      end
+    end
+    
+    def self.Db(database_name = nil)
+      database_name ||= CouchPotato::Config.database_name || raise('No Database configured. Set CouchPotato::Config.database_name')
+      full_url_to_database = database_name
+      if full_url_to_database !~ /^http:\/\//
+        full_url_to_database = "http://localhost:5984/#{database_name}"
+      end
+      CouchRest.database!(full_url_to_database)
+    end
+  end    
+end

data/lib/couch_potato/versioning.rb

@@ -0,0 +1,46 @@
+module CouchPotato
+  module Versioning
+    def self.included(base)
+      base.class_eval do
+        property :version
+        property :master_version_id
+        cattr_accessor :new_version_condition
+        before_create :set_version_default
+        before_update :prepare_for_new_version
+        
+        def self.set_version_condition(lambda)
+          self.new_version_condition = lambda
+        end
+      end
+    end
+    
+    def versions(version_no = nil)
+      if version_no
+        CouchPotato::Persistence::Finder.new.find(self.class, :version => version_no).first
+      elsif version == 1
+        [self]
+      else
+        CouchPotato::Persistence::Finder.new.find(self.class, :master_version_id => _id).sort_by(&:version)
+      end
+    end
+    
+    private
+    
+    def set_version_default
+      self.version ||= 1
+    end
+    
+    def prepare_for_new_version
+      if new_version_condition.nil? || new_version_condition.call(self)
+        copy = self.class.get self._id
+        copy._id = nil
+        copy._rev = nil
+        copy.master_version_id = self._id
+        copy.save
+        self.master_version_id ||= self.id
+        self.version += 1
+      end
+    end
+    
+  end
+end

data/lib/couch_potato.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'active_support'
+require 'json'
+require 'json/add/core'
+require 'json/add/rails'
+
+require 'ostruct'
+
+module CouchPotato
+  Config = OpenStruct.new
+end
+
+require File.dirname(__FILE__) + '/core_ext/object'
+require File.dirname(__FILE__) + '/core_ext/time'
+
+require File.dirname(__FILE__) + '/couch_potato/persistence'
+require File.dirname(__FILE__) + '/couch_potato/versioning'
+require File.dirname(__FILE__) + '/couch_potato/ordering'
+require File.dirname(__FILE__) + '/couch_potato/active_record/compatibility'
+

data/spec/attributes_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'attributes=' do
+  
+  class Plant
+    include CouchPotato::Persistence
+    property :leaf_count
+  end
+  
+  it "should assign the attributes" do
+    plant = Plant.new 
+    plant.attributes = {:leaf_count => 1}
+    plant.leaf_count.should == 1
+  end
+end
+
+describe "attributes" do
+  it "should return the attributes" do
+    plant = Plant.new :leaf_count => 1
+    plant.attributes .should == {:leaf_count => 1}
+  end
+end

data/spec/belongs_to_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'belongs_to' do
+  before(:each) do
+    @commenter = Commenter.create!
+  end
+  
+  it "should return nil by default" do
+    c = Comment.new :title => 'title'
+    c.commenter.should be_nil
+    c.commenter_id.should be_nil
+  end
+  
+  it "should assign the parent object" do
+    c = Comment.new :title => 'title'
+    c.commenter = @commenter
+    c.commenter.should == @commenter
+    c.commenter_id.should == @commenter.id
+  end
+  
+  it "should assign the parent object id" do
+    c = Comment.new :title => 'title'
+    c.commenter_id = @commenter.id
+    c.commenter.should == @commenter
+    c.commenter_id.should == @commenter.id
+  end
+  
+  it "should persist the link to the parent object" do
+    c = Comment.new :title => 'title'
+    c.commenter_id = @commenter.id
+    c.save!
+    c = Comment.find c.id
+    c.commenter._id.should == @commenter.id
+    c.commenter_id.should == @commenter._id
+  end
+  
+end

data/spec/callbacks_spec.rb

@@ -0,0 +1,229 @@
+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
+  
+  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.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
+  end
+  
+  describe "successful create" do
+    before(:each) do
+       @recorder.required_property = 1
+    end
+    
+    it "should call before_validation_on_create" do
+      @recorder.save!
+      @recorder.callbacks.should include(:before_validation_on_create)
+    end
+    
+    it "should call before_validation_on_save" do
+      @recorder.save!
+      @recorder.callbacks.should include(:before_validation_on_save)
+    end
+    
+    it "should call before_save" do
+      @recorder.save!
+      @recorder.callbacks.should include(:before_save)
+    end
+    
+    it "should call after_save" do
+      @recorder.save!
+      @recorder.callbacks.should include(:after_save)
+    end
+    
+    it "should call before_create" do
+      @recorder.save!
+      @recorder.callbacks.should include(:before_create)
+    end
+    
+    it "should call after_create" do
+      @recorder.save!
+      @recorder.callbacks.should include(:after_create)
+    end
+    
+  end
+  
+  describe "failed create" do
+    
+    it "should call before_validation_on_create" do
+      @recorder.save
+      @recorder.callbacks.should include(:before_validation_on_create)
+    end
+    
+    it "should call before_validation_on_save" do
+      @recorder.save
+      @recorder.callbacks.should include(:before_validation_on_save)
+    end
+    
+    it "should not call before_save" do
+      @recorder.save
+      @recorder.callbacks.should_not include(:before_save)
+    end
+    
+    it "should not call after_save" do
+      @recorder.save
+      @recorder.callbacks.should_not include(:after_save)
+    end
+    
+    it "should not call before_create" do
+      @recorder.save
+      @recorder.callbacks.should_not include(:before_create)
+    end
+    
+    it "should not call after_create" do
+      @recorder.save
+      @recorder.callbacks.should_not include(:after_create)
+    end
+    
+  end
+  
+  
+end
+
+describe "update callbacks" do
+  
+  before(:each) do
+    @recorder = CallbackRecorder.create! :required_property => 1
+    @recorder.callbacks.clear
+  end
+  
+  describe "successful update" do
+    
+    it "should call before_validation_on_update" do
+      @recorder.save!
+      @recorder.callbacks.should include(:before_validation_on_update)
+    end
+    
+    it "should call before_validation_on_save" do
+      @recorder.save!
+      @recorder.callbacks.should include(:before_validation_on_save)
+    end
+    
+    it "should call before_save" do
+      @recorder.save!
+      @recorder.callbacks.should include(:before_save)
+    end
+    
+    it "should call after_save" do
+      @recorder.save!
+      @recorder.callbacks.should include(:after_save)
+    end
+    
+    it "should call before_update" do
+      @recorder.save!
+      @recorder.callbacks.should include(:before_update)
+    end
+    
+    it "should call after_update" do
+      @recorder.save!
+      @recorder.callbacks.should include(:after_update)
+    end
+    
+  end
+  
+  describe "failed update" do
+    
+    before(:each) do
+       @recorder.required_property = nil
+    end
+    
+    it "should call before_validation_on_update" do
+      @recorder.save
+      @recorder.callbacks.should include(:before_validation_on_update)
+    end
+    
+    it "should call before_validation_on_save" do
+      @recorder.save
+      @recorder.callbacks.should include(:before_validation_on_save)
+    end
+    
+    it "should not call before_save" do
+      @recorder.save
+      @recorder.callbacks.should_not include(:before_save)
+    end
+    
+    it "should not call after_save" do
+      @recorder.save
+      @recorder.callbacks.should_not include(:after_save)
+    end
+    
+    it "should not call before_update" do
+      @recorder.save
+      @recorder.callbacks.should_not include(:before_update)
+    end
+    
+    it "should not call after_update" do
+      @recorder.save
+      @recorder.callbacks.should_not include(:after_update)
+    end
+    
+  end
+  
+end
+
+describe "destroy callbacks" do
+  before(:each) do
+    @recorder = CallbackRecorder.create! :required_property => 1
+    @recorder.callbacks.clear
+  end
+  
+  it "should call before_destroy" do
+    @recorder.destroy
+    @recorder.callbacks.should include(:before_destroy)
+  end
+  
+  it "should call after_destroy" do
+    @recorder.destroy
+    @recorder.callbacks.should include(:after_destroy)
+  end
+end