simply_stored 0.1.4

data/lib/simply_stored/couch.rb

@@ -0,0 +1,278 @@
+require 'couch_potato'
+
+require File.expand_path(File.dirname(__FILE__) + '/../simply_stored')
+require 'simply_stored/couch/validations'
+require 'simply_stored/couch/belongs_to'
+require 'simply_stored/couch/has_many'
+require 'simply_stored/couch/has_one'
+require 'simply_stored/couch/ext/couch_potato'
+require 'simply_stored/couch/views'
+
+module SimplyStored
+  module Couch
+    def self.included(clazz)
+      clazz.class_eval do
+        include CouchPotato::Persistence
+        include InstanceMethods
+        extend ClassMethods
+      end
+      
+      clazz.instance_eval do
+        attr_accessor :_accessible_attributes, :_protected_attributes
+        alias :simpledb_array :simpledb_string
+        alias :simpledb_integer :simpledb_string
+        
+        view :all_documents, :key => :created_at
+      end
+    end
+    
+    module ClassMethods
+      include SimplyStored::ClassMethods::Base
+      include SimplyStored::Couch::Validations
+      include SimplyStored::Couch::BelongsTo
+      include SimplyStored::Couch::HasMany
+      include SimplyStored::Couch::HasOne
+      include SimplyStored::Storage::ClassMethods
+      
+      def create(attributes = {}, &blk)
+        instance = new(attributes, &blk)
+        instance.save
+        instance
+      end
+
+      def create!(attributes = {}, &blk)
+        instance = new(attributes, &blk)
+        instance.save!
+        instance
+      end
+      
+      def find(*args)
+        what = args.shift
+        options = args.last.is_a?(Hash) ? args.last : {}
+        
+        options.assert_valid_keys(:with_deleted)
+        with_deleted = options.delete(:with_deleted)
+        
+        case what
+        when :all
+          if with_deleted || !soft_deleting_enabled?
+            CouchPotato.database.view(all_documents(*args))
+          else
+            CouchPotato.database.view(all_documents_without_deleted(:key => nil))
+          end
+        when :first
+          if with_deleted || !soft_deleting_enabled?
+            CouchPotato.database.view(all_documents(:limit => 1)).first
+          else
+            CouchPotato.database.view(all_documents_without_deleted(:key => nil, :limit => 1)).first
+          end
+        else          
+          raise SimplyStored::Error, "Can't load record without an id" if what.nil?
+          document = CouchPotato.database.load_document(what)
+          if document.nil? or !document.is_a?(self) or (document.deleted? && !with_deleted)
+            raise(SimplyStored::RecordNotFound)
+          end
+          document
+        end
+      end
+      
+      def all
+        find(:all)
+      end
+      
+      def first
+        find(:first)
+      end
+      
+      def count(options = {})
+        options.assert_valid_keys(:with_deleted)
+        with_deleted = options[:with_deleted]
+        
+        if with_deleted || !soft_deleting_enabled?
+          CouchPotato.database.view(all_documents(:reduce => true))
+        else
+          CouchPotato.database.view(all_documents_without_deleted(:reduce => true, :key => nil))
+        end
+      end
+      
+      def enable_soft_delete(property_name = :deleted_at)
+        @_soft_delete_attribute = property_name.to_sym
+        property property_name, :type => Time
+        _define_hard_delete_methods
+        _define_soft_delete_views
+      end
+      
+      def soft_delete_attribute
+        @_soft_delete_attribute
+      end
+      
+      def soft_deleting_enabled?
+        !soft_delete_attribute.nil?
+      end
+      
+      def simpledb_string(*names)
+        names.each do |name|
+          property name
+        end
+      end
+      
+      def simpledb_timestamp(*names)
+        names.each do |name|
+          property name, :type => Time
+        end
+      end
+      
+      def require_attributes(*names)
+        names.each do |name|
+          validates_presence_of name
+        end
+      end
+
+      def require_inclusion_of(name, valid_set, options = {})
+        options.update(:in => valid_set)
+        validates_inclusion_of(name, options)
+      end
+      
+      def require_format_of(attr, valid_regex, options = {})
+        options.update(:with => valid_regex)
+        validates_format_of(attr, options)
+      end
+      
+      def _define_find_by(name, *args)
+        keys = name.to_s.gsub(/^find_by_/, "").split("_and_")
+        view_name = name.to_s.gsub(/^find_/, "").to_sym
+        view_keys = keys.length == 1 ? keys.first : keys
+        without_deleted_view_name = "#{view_name}_withoutdeleted"
+        without_deleted_view_keys = keys + [:deleted_at]
+        
+        unless respond_to?(view_name)
+          puts "Warning: Defining view #{self.name}##{view_name} with keys #{view_keys.inspect} at call time, please add it to the class body. (Called from #{caller[0]})"
+          view(view_name, :key => view_keys)
+        end
+        
+        if !respond_to?(without_deleted_view_name) && soft_deleting_enabled?
+          puts "Warning: Defining view #{self.name}##{without_deleted_view_name} with keys #{without_deleted_view_keys.inspect} at call time, please add it to the class body. (Called from #{caller[0]})"
+          view(without_deleted_view_name, :key => without_deleted_view_keys)
+        end
+        
+        (class << self; self end).instance_eval do
+          define_method(name) do |*key_args|
+            options = key_args.last.is_a?(Hash) ? key_args.pop : {}
+            options.assert_valid_keys(:with_deleted)
+            with_deleted = options.delete(:with_deleted)
+            
+            raise ArgumentError, "Too many or too few arguments, require #{keys.inspect}" unless keys.size == key_args.size            
+            
+            if soft_deleting_enabled? && !with_deleted
+              key_args = key_args + [nil] # deleted_at
+              CouchPotato.database.view(send(without_deleted_view_name, :key => (key_args.size == 1 ? key_args.first : key_args), :limit => 1, :include_docs => true)).first
+            else
+              CouchPotato.database.view(send(view_name, :key => (key_args.size == 1 ? key_args.first : key_args), :limit => 1, :include_docs => true)).first
+            end
+          end
+        end
+        
+        send(name, *args)
+      end
+      
+      def _define_find_all_by(name, *args)
+        keys = name.to_s.gsub(/^find_all_by_/, "").split("_and_")
+        view_name = name.to_s.gsub(/^find_all_/, "").to_sym
+        view_keys = keys.length == 1 ? keys.first : keys
+        without_deleted_view_name = "#{view_name}_withoutdeleted"
+        without_deleted_view_keys = keys + [:deleted_at]
+        
+        unless respond_to?(view_name)
+          puts "Warning: Defining view #{self.name}##{view_name} with keys #{view_keys.inspect} at call time, please add it to the class body. (Called from #{caller[0]})"
+          view(view_name, :key => view_keys)
+        end
+        
+        if !respond_to?(without_deleted_view_name) && soft_deleting_enabled?
+          puts "Warning: Defining view #{self.name}##{without_deleted_view_name} with keys #{without_deleted_view_keys.inspect} at call time, please add it to the class body. (Called from #{caller[0]})"
+          view(without_deleted_view_name, :key => without_deleted_view_keys)
+        end
+        
+        (class << self; self end).instance_eval do
+          define_method(name) do |*key_args|
+            options = key_args.last.is_a?(Hash) ? key_args.pop : {}
+            options.assert_valid_keys(:with_deleted)
+            with_deleted = options.delete(:with_deleted)
+            
+            raise ArgumentError, "Too many or too few arguments, require #{keys.inspect}" unless keys.size == key_args.size            
+            
+            if soft_deleting_enabled? && !with_deleted
+              key_args = key_args + [nil] # deleted_at
+              CouchPotato.database.view(send(without_deleted_view_name, :key => (key_args.size == 1 ? key_args.first : key_args), :include_docs => true))
+            else
+              CouchPotato.database.view(send(view_name, :key => (key_args.size == 1 ? key_args.first : key_args), :include_docs => true))
+            end
+          end
+        end
+        send(name, *args)
+      end
+      
+      def _define_count_by(name, *args)
+        keys = name.to_s.gsub(/^count_by_/, "").split("_and_")
+        view_name = name.to_s.gsub(/^count_/, "").to_sym
+        view_keys = keys.length == 1 ? keys.first : keys
+        without_deleted_view_name = "#{view_name}_withoutdeleted"
+        without_deleted_view_keys = keys + [:deleted_at]
+        
+        unless respond_to?(view_name)
+          puts "Warning: Defining view #{self.name}##{view_name} with keys #{view_keys.inspect} at call time, please add it to the class body. (Called from #{caller[0]})"
+          view(view_name, :key => view_keys)
+        end
+        
+        if !respond_to?(without_deleted_view_name) && soft_deleting_enabled?
+          puts "Warning: Defining view #{self.name}##{without_deleted_view_name} with keys #{without_deleted_view_keys.inspect} at call time, please add it to the class body. (Called from #{caller[0]})"
+          view(without_deleted_view_name, :key => without_deleted_view_keys)
+        end
+        
+        (class << self; self end).instance_eval do
+          define_method("#{name}") do |*key_args|
+            options = key_args.last.is_a?(Hash) ? key_args.pop : {}
+            options.assert_valid_keys(:with_deleted)
+            with_deleted = options.delete(:with_deleted)
+            
+            if soft_deleting_enabled? && !with_deleted
+              key_args = key_args + [nil] # deleted_at
+              CouchPotato.database.view(send(without_deleted_view_name, :key => (key_args.size == 1 ? key_args.first : key_args), :reduce => true))
+            else
+              CouchPotato.database.view(send(view_name, :key => (key_args.size == 1 ? key_args.first : key_args), :reduce => true))
+            end
+            
+          end
+        end
+      
+        send(name, *args)
+      end
+      
+      def method_missing(name, *args)
+        if name.to_s =~ /^find_by/
+          _define_find_by(name, *args)
+        elsif name.to_s =~ /^find_all_by/
+          _define_find_all_by(name, *args)
+        elsif name.to_s =~ /^count_by/
+          _define_count_by(name, *args)
+        else
+          super
+        end
+      end
+      
+      def _define_hard_delete_methods
+        define_method("destroy!") do
+          destroy(true)
+        end
+        
+        define_method("delete!") do
+          destroy(true)
+        end
+      end
+      
+      def _define_soft_delete_views 
+        view :all_documents_without_deleted, :key => soft_delete_attribute
+      end
+      
+    end
+  end
+end

data/lib/simply_stored/instance_methods.rb

@@ -0,0 +1,143 @@
+module SimplyStored
+  module InstanceMethods
+    
+    def initialize(attributes = {}, &blk)
+      super(_remove_protected_attributes(attributes))
+      blk.call(self) if blk
+    end
+    
+    def ==(other)
+      other._id == _id && other._rev == _rev
+    end
+
+    def eql?(other)
+      self.==(other)
+    end
+
+    def save(validate = true)
+      CouchPotato.database.save_document(self, validate)
+    end
+
+    def save!
+      CouchPotato.database.save_document!(self)
+    end
+
+    def destroy(override_soft_delete=false)
+      check_and_destroy_dependents
+      if self.class.soft_deleting_enabled? && !override_soft_delete
+        _mark_as_deleted
+      else
+        self.skip_callbacks = true if self.class.soft_deleting_enabled? && deleted?
+        CouchPotato.database.destroy_document(self)
+        freeze
+      end
+    end
+    alias :delete :destroy
+
+    def update_attributes(attributes = {})
+      self.attributes = attributes
+      save
+    end
+    
+    def attributes=(attr)
+      super(_remove_protected_attributes(attr))
+    end
+
+    def reload
+      instance = self.class.find(_id, :with_deleted => true)
+      instance.attributes.each do |attribute, value|
+        send "#{attribute}=", value
+      end
+      self._rev = instance._rev
+      reset_dirty_attributes
+      reset_association_caches
+      self
+    end
+    
+    def deleted?
+      if self.class.soft_deleting_enabled?
+        !send(self.class.soft_delete_attribute).nil?
+      else
+        false
+      end
+    end
+    
+    protected
+    
+    def reset_association_caches
+      self.class.properties.each do |property|
+        if property.respond_to?(:association?) && property.association?
+          instance_variable_set("@#{property.name}", nil)
+        end
+      end
+    end
+    
+    def _remove_protected_attributes(attrs)
+      return {} if attrs.blank?
+      attrs = attrs.dup.stringify_keys
+      (self.class.instance_variable_get(:@_protected_attributes) || []).map(&:to_s).each do |protected_attribute|
+        attrs.delete(protected_attribute)
+      end
+
+      accessible_attributes = (self.class.instance_variable_get(:@_accessible_attributes) || []).map(&:to_s)
+
+      if accessible_attributes.present?
+        attrs.each do |attr_key, attr_value|
+          attrs.delete(attr_key) unless accessible_attributes.include?(attr_key)
+        end
+      end
+
+      attrs
+    end
+    
+    def check_and_destroy_dependents
+      self.class.properties.each do |property|
+        if property.respond_to?(:association?) and property.association?
+          next unless property.options[:dependent]
+          next if property.options[:through]
+          dependents = send(property.name, :force_reload => true)
+          dependents = [dependents] unless dependents.is_a?(Array)
+          dependents.reject{|d| d.nil?}.each do |dependent|
+            case property.options[:dependent]
+            when :destroy
+              dependent.destroy
+            else
+              unless dependent.class.soft_deleting_enabled?
+                dependent.send("#{self.class.foreign_property}=", nil)
+                dependent.save(false)
+              end
+            end
+          end
+        end
+      end
+    end
+    
+    def find_one_associated(from, to, options = {})
+      options = {
+        :limit => 1, 
+        :descending => true
+      }.update(options)
+      find_associated(from, to, options).first
+    end
+    
+    def find_associated(from, to, options = {})
+      if options[:with_deleted]
+        CouchPotato.database.view(
+          self.class.get_class_from_name(from).send(
+            "association_#{from.to_s.singularize.underscore}_belongs_to_#{to.name.singularize.underscore}_with_deleted", :key => id))
+      else
+        CouchPotato.database.view(
+          self.class.get_class_from_name(from).send(
+            "association_#{from.to_s.singularize.underscore}_belongs_to_#{to.name.singularize.underscore}", :key => id))
+      end
+    end
+    
+    def _mark_as_deleted
+      run_callbacks(:before_destroy)
+      send("#{self.class.soft_delete_attribute}=", Time.now)
+      save(false)
+      run_callbacks(:after_destroy)
+    end
+    
+  end
+end

data/lib/simply_stored/simpledb/associations.rb

@@ -0,0 +1,196 @@
+module SimplyStored
+  module SimpleDB
+    module Associations
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    
+      module ClassMethods
+        def belongs_to(klass_name)
+          define_belongs_to_getter(klass_name)
+          define_belongs_to_setter(klass_name)
+        end
+  
+        def has_one(klass_name, options = {})
+          options = {
+            :clear => :nullify, # or :destroy
+            :dependent => :nullify # or :destroy
+          }.update(options)
+    
+         define_has_one_getter(klass_name, options)
+         define_has_one_setter(klass_name, options)
+         define_has_one_dependent_clearing(klass_name, options)
+        end
+  
+        def has_many(klass_name, options = {})
+          options = {
+            :clear => :nullify, # or :destroy
+            :dependent => :nullify # or :destroy
+          }.update(options)
+    
+          define_has_many_getter(klass_name, options)
+          define_has_many_setter_add(klass_name, options)
+          define_has_many_setter_remove(klass_name, options)
+          define_has_many_setter_remove_all(klass_name, options)
+          define_has_many_dependent_clearing(klass_name, options)
+        end
+      
+        def define_belongs_to_getter(klass_name)
+          define_method klass_name.to_s do
+            klass = self.class.get_class_from_name(klass_name)
+            cached_version = instance_variable_get("@_cached_belongs_to_#{klass_name}")
+            if cached_version.nil? and self["#{klass_name}_id"].present?
+              cached_version = klass.find(self.send("#{klass_name}_id"), :auto_load => true)
+              instance_variable_set("@_cached_belongs_to_#{klass_name}", cached_version)
+            end
+            cached_version
+          end
+        end
+
+        def define_belongs_to_setter(klass_name)
+          define_method "#{klass_name}=" do |val|
+            klass = self.class.get_class_from_name(klass_name)
+            raise ArgumentError, "expected #{klass} got #{val.class}" unless val.is_a?(klass)
+            self.send("#{klass_name}_id=", val.id)
+            instance_variable_set("@_cached_belongs_to_#{klass_name}", val)
+          end
+        end
+
+        def define_has_one_getter(klass_name, options)
+          define_method klass_name.to_s do
+            klass = self.class.get_class_from_name(klass_name)
+            cached_version = instance_variable_get("@_cached_has_one_#{klass_name}")
+            if cached_version
+              return cached_version
+            else
+              cached_version = klass.send("find_by_#{self.class.foreign_key}".to_sym, self.id, {:auto_load => true})
+              instance_variable_set("@_cached_has_one_#{klass_name}", cached_version)
+              return cached_version
+            end
+          end
+        end
+
+        def define_has_one_setter(klass_name, options)
+          define_method "#{klass_name}=" do |val|
+            klass = self.class.get_class_from_name(klass_name)
+            raise ArgumentError, "expected #{klass} got #{val.class}" unless val.is_a?(klass)
+
+            # clear old
+            old = self.send("#{klass_name}")
+            old.send("#{self.class.foreign_key}=", nil) if old && options[:clear] == :nullify
+            old.delete if old && options[:clear] == :destroy
+
+            # store new
+            val.send("#{self.class.foreign_key}=", self.id)
+            instance_variable_set("@_cached_has_one_#{klass_name}", val)
+          end
+        end
+
+        def define_has_one_dependent_clearing(klass_name, options)
+          # add method to list of methods to run when deleted
+          @_clear_dependents_after_delete_methods ||= []
+          @_clear_dependents_after_delete_methods << "has_one_clear_#{klass_name}_after_destroy"
+
+          # define actual clearing/deleting
+          define_method "has_one_clear_#{klass_name}_after_destroy" do
+            klass = self.class.get_class_from_name(klass_name)
+            dependent = klass.send("find_by_#{self.class.foreign_key}".to_sym, self.id)
+            if options[:dependent] == :nullify
+              dependent.send("#{self.class.foreign_key}=", nil) if dependent
+            elsif options[:dependent] == :destroy
+              dependent.delete if dependent
+            else
+              raise ArgumentError, "unknown dependent method: #{options[:dependent].inspect}"
+            end
+          end
+        end
+
+        def define_has_many_getter(klass_name, options)
+          define_method klass_name.to_s do
+            klass = self.class.get_class_from_name(klass_name)
+            cached_version = instance_variable_get("@_cached_has_many_#{klass_name}")
+            if cached_version
+              return cached_version
+            else
+              cached_version = klass.send("find_all_by_#{self.class.foreign_key}".to_sym, self.id, {:auto_load => true})
+              instance_variable_set("@_cached_has_many_#{klass_name}", cached_version)
+              return cached_version
+            end
+          end
+        end
+
+        def define_has_many_setter_add(klass_name, options)
+          define_method "add_#{klass_name.to_s.singularize}" do |val|
+            klass = self.class.get_class_from_name(klass_name)
+            raise ArgumentError, "expected #{klass} got #{val.class}" unless val.is_a?(klass)
+            val.send("#{self.class.foreign_key}=", self.id)
+            val.save(false)
+            cached_version = instance_variable_get("@_cached_has_many_#{klass_name}") || []
+            instance_variable_set("@_cached_has_many_#{klass_name}", cached_version << val)
+          end
+        end
+
+        def define_has_many_setter_remove(klass_name, options)
+          define_method "remove_#{klass_name.to_s.singularize}" do |val|
+            klass = self.class.get_class_from_name(klass_name)
+            raise ArgumentError, "expected #{klass} got #{val.class}" unless val.is_a?(klass)
+            raise ArgumentError, "cannot remove not mine" unless val.send(self.class.foreign_key.to_sym) == self.id
+            if options[:clear] == :nullify
+              val.send("#{self.class.foreign_key}=", nil) 
+              val.save(false)
+            elsif options[:clear] == :destroy
+              val.delete
+            else
+              raise "Unknown option for clear: #{option[:clear]}"
+            end
+            cached_version = instance_variable_get("@_cached_has_many_#{klass_name}") || []
+            instance_variable_set("@_cached_has_many_#{klass_name}", cached_version.delete_if{|x| x.id == val.id})
+          end
+        end
+
+        def define_has_many_setter_remove_all(klass_name, options)
+          define_method "remove_all_#{klass_name}" do
+            klass = self.class.get_class_from_name(klass_name)
+
+            all = klass.send("find_all_by_#{self.class.foreign_key}".to_sym, self.id)
+
+            all.each do |item|
+              self.send("remove_#{klass_name.to_s.singularize}", item)
+            end
+            instance_variable_set("@_cached_has_many_#{klass_name}", [])
+          end
+        end
+
+        def define_has_many_dependent_clearing(klass_name, options)
+          # add method to list of methods to run when deleted
+          @_clear_dependents_after_delete_methods ||= []
+          @_clear_dependents_after_delete_methods << "has_many_clear_#{klass_name}_after_destroy"
+
+          # define actual clearing/deleting
+          define_method "has_many_clear_#{klass_name}_after_destroy" do
+            klass = self.class.get_class_from_name(klass_name)
+            dependents = klass.send("find_all_by_#{self.class.foreign_key}".to_sym, self.id)
+            if options[:dependent] == :nullify
+              dependents.each do |dependent|
+                dependent.send("#{self.class.foreign_key}=", nil)
+              end
+            elsif options[:dependent] == :destroy
+              dependents.each do |dependent|
+                dependent.delete
+              end
+            else
+              raise ArgumentError, "unknown dependent method: #{options[:dependent].inspect}"
+            end
+          end
+        end
+      end
+    
+      def clear_dependents_after_delete
+        clear_methods = self.class.instance_variable_get("@_clear_dependents_after_delete_methods") || []
+        clear_methods.uniq.each do |clear_method|
+          self.send(clear_method)
+        end
+      end
+    end
+  end
+end