simply_stored 0.1.4

data/lib/simply_stored/class_methods_base.rb

@@ -0,0 +1,31 @@
+module SimplyStored
+  module ClassMethods
+    module Base
+      def get_class_from_name(klass_name)
+        klass_name.to_s.gsub('__','/').gsub('__','::').classify.constantize
+      end
+      
+      def foreign_key
+        name.underscore.gsub('/','__').gsub('::','__') + "_id"
+      end
+      
+      def foreign_property
+        name.underscore.gsub('/','__').gsub('::','__')
+      end
+      
+      def attr_protected(*args)
+        @_protected_attributes ||= []
+        @_protected_attributes += args.to_a
+      end
+      
+      def attr_accessible(*args)
+        @_accessible_attributes ||= []
+        @_accessible_attributes += args.to_a
+      end
+      
+      def _find_property(name)
+        properties.find{|property| property.name == name}
+      end
+    end
+  end
+end

data/lib/simply_stored/couch/belongs_to.rb

@@ -0,0 +1,117 @@
+# Gracefully taken from CouchPotato after it has been removed for good.
+module SimplyStored
+  module Couch
+    module BelongsTo
+      
+      def belongs_to(name)
+        map_definition_without_deleted = <<-eos
+          function(doc) { 
+            if (doc['ruby_class'] == '#{self.to_s}' && doc['#{name.to_s}_id'] != null) {
+              if (doc['#{soft_delete_attribute}'] && doc['#{soft_delete_attribute}'] != null){
+                // "soft" deleted
+              }else{
+                emit(doc.#{name.to_s}_id, null);
+              }
+            }
+          }
+        eos
+         
+        view "association_#{self.name.underscore}_belongs_to_#{name}",
+          :map => map_definition_without_deleted,
+          :type => "custom",
+          :include_docs => true
+          
+        map_definition_with_deleted = <<-eos
+          function(doc) { 
+            if (doc['ruby_class'] == '#{self.to_s}' && doc['#{name.to_s}_id'] != null) {
+              emit(doc.#{name.to_s}_id, null);
+            }
+          }
+        eos
+         
+        view "association_#{self.name.underscore}_belongs_to_#{name}_with_deleted",
+          :map => map_definition_with_deleted,
+          :type => "custom",
+          :include_docs => true
+            
+        property name, :class => SimplyStored::Couch::BelongsTo::Property
+      end
+
+      class Property #:nodoc:
+        attr_accessor :name, :options
+      
+        def initialize(owner_clazz, name, options = {})
+          @name, @options = name, options
+          item_class_name = self.item_class_name
+          owner_clazz.class_eval do
+            attr_reader "#{name}_id"
+            attr_accessor "#{name}_id_was"
+            
+            define_method name do |*args|
+              options = args.last.is_a?(Hash) ? args.last : {}
+              options.assert_valid_keys(:force_reload, :with_deleted)
+              forced_reload = options[:force_reload] || false
+              with_deleted = options[:with_deleted] || false
+              
+              return instance_variable_get("@#{name}") unless instance_variable_get("@#{name}").nil? or forced_reload
+              instance_variable_set("@#{name}", send("#{name}_id") ? Object.const_get(item_class_name).find(send("#{name}_id"), :with_deleted => with_deleted) : nil)
+            end
+          
+            define_method "#{name}=" do |value|
+              klass = self.class.get_class_from_name(name)
+              raise ArgumentError, "expected #{klass} got #{value.class}" unless value.nil? || value.is_a?(klass)
+              
+              instance_variable_set("@#{name}", value)
+              if value.nil?
+                instance_variable_set("@#{name}_id", nil)
+              else
+                instance_variable_set("@#{name}_id", value.id)
+              end
+            end
+
+            define_method "#{name}_id=" do |id|
+              remove_instance_variable("@#{name}") if instance_variable_defined?("@#{name}")
+              instance_variable_set("@#{name}_id", id)
+            end
+            
+            define_method "#{name}_changed?" do
+              self.send("#{name}_id") != self.send("#{name}_id_was")
+            end
+          end
+        end
+      
+        def save(object)
+        end
+
+        def dirty?(object)
+          object.send("#{name}_id_was") != object.send("#{name}_id")
+        end
+        
+        def reset_dirty_attribute(object)
+          object.send("#{name}_id_was=", object.send("#{name}_id"))
+        end
+        
+        def destroy(object)
+        
+        end
+      
+        def build(object, json)
+          object.send "#{name}_id=", json["#{name}_id"]
+          object.send "#{name}_id_was=", json["#{name}_id"]
+        end
+      
+        def serialize(json, object)
+          json["#{name}_id"] = object.send("#{name}_id") if object.send("#{name}_id")
+        end
+      
+        def item_class_name
+          @name.to_s.camelize
+        end
+      
+        def association?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/simply_stored/couch/ext/couch_potato.rb

@@ -0,0 +1,16 @@
+module CouchPotato
+  module Persistence
+    module DirtyAttributes
+      private
+      
+      def reset_dirty_attributes
+        self.class.properties.each do |property|
+          if !property.respond_to?(:supports_dirty?) || property.supports_dirty?
+            property.respond_to?(:reset_dirty_attribute) ? property.reset_dirty_attribute(self) :
+              instance_variable_set("@#{property.name}_was", send(property.name))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simply_stored/couch/has_many.rb

@@ -0,0 +1,148 @@
+module SimplyStored
+  module Couch
+    module HasMany
+      def has_many(name, options = {})
+        property name, options.merge(:class => SimplyStored::Couch::HasMany::Property)
+      end
+
+      def define_has_many_getter(name)
+        define_method(name) do |*args|
+          options = args.first && args.first.is_a?(Hash) && args.first
+          if options
+            options.assert_valid_keys(:force_reload, :with_deleted)
+            forced_reload = options[:force_reload]
+            with_deleted = options[:with_deleted]
+          else
+            forced_reload = false
+            with_deleted = false
+          end
+
+          if forced_reload || instance_variable_get("@#{name}").nil?
+            instance_variable_set("@#{name}", find_associated(name, self.class, :with_deleted => with_deleted))
+          end
+          instance_variable_get("@#{name}")
+        end
+      end
+      
+      def define_has_many_through_getter(name, through)
+        raise ArgumentError, "no such relation: #{self} - #{through}" unless instance_methods.map(&:to_sym).include?(through.to_sym)
+        
+        define_method(name) do |*args|
+          options = args.first && args.first.is_a?(Hash) && args.first
+          if options
+            options.assert_valid_keys(:force_reload, :with_deleted)
+            forced_reload = options[:force_reload]
+            with_deleted = options[:with_deleted]
+          else
+            forced_reload = false
+            with_deleted = false
+          end
+          
+          if forced_reload || instance_variable_get("@#{name}").nil?
+            
+            # there is probably a faster way to query this
+            intermediate_objects = find_associated(through, self.class, :with_deleted => with_deleted)
+            
+            through_objects = intermediate_objects.map do |intermediate_object|
+              intermediate_object.send(name.to_s.singularize.underscore, :with_deleted => with_deleted)
+            end.flatten.uniq
+            
+            instance_variable_set("@#{name}", through_objects)
+          end
+          instance_variable_get("@#{name}")
+        end
+      end
+      
+      def define_has_many_setter_add(name)
+        define_method("add_#{name.to_s.singularize}") do |value|
+          klass = self.class.get_class_from_name(name)
+          raise ArgumentError, "expected #{klass} got #{value.class}" unless value.is_a?(klass)
+          
+          value.send("#{self.class.foreign_key}=", id)
+          value.save
+          cached_version = instance_variable_get("@#{name}") || []
+          instance_variable_set("@#{name}", cached_version << value)
+        end
+      end
+
+      def define_has_many_setter_remove(name)
+        define_method "remove_#{name.to_s.singularize}" do |value|
+          klass = self.class.get_class_from_name(name)
+          raise ArgumentError, "expected #{klass} got #{value.class}" unless value.is_a?(klass)
+          raise ArgumentError, "cannot remove not mine" unless value.send(self.class.foreign_key.to_sym) == id
+          
+          if self.class._find_property(name).options[:dependent] == :destroy
+            value.destroy
+          else
+            value.send("#{self.class.foreign_key}=", nil) 
+            value.save
+          end
+          
+          cached_version = instance_variable_get("@#{name}") || []
+          instance_variable_set("@#{name}", cached_version.delete_if{|item| item.id == value.id})
+        end
+      end
+      
+      def define_has_many_setter_remove_all(name)
+        define_method "remove_all_#{name}" do
+          all = send("#{name}", :force_reload => true)
+          
+          all.collect{|i| i}.each do |item|
+            send("remove_#{name.to_s.singularize}", item)
+          end
+        end
+      end
+      
+      class Property
+        attr_reader :name, :options
+        
+        def initialize(owner_clazz, name, options = {})
+          options = {
+            :dependent => :nullify,
+            :through => nil
+          }.update(options)
+          @name, @options = name, options
+          
+          options.assert_valid_keys(:dependent, :through)
+          
+          if options[:through]
+            owner_clazz.class_eval do
+              define_has_many_through_getter(name, options[:through])
+            end
+          else
+            owner_clazz.class_eval do
+              define_has_many_getter(name)
+              define_has_many_setter_add(name)
+              define_has_many_setter_remove(name)
+              define_has_many_setter_remove_all(name)
+            end
+          end
+        end
+        
+        def save(object)
+        end
+
+        def dirty?(object)
+          false
+        end
+
+        def destroy(object)
+        end
+
+        def build(object, json)
+        end
+
+        def serialize(json, object)
+        end
+        
+        def supports_dirty?
+          false
+        end
+        
+        def association?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/simply_stored/couch/has_one.rb

@@ -0,0 +1,93 @@
+module SimplyStored
+  module Couch
+    module HasOne
+      def has_one(name, options = {})
+        property name, options.merge(:class => SimplyStored::Couch::HasOne::Property)
+      end
+      
+      def define_has_one_setter(name)
+        define_method("#{name}=") do |value|
+          klass = self.class.get_class_from_name(name)
+          raise ArgumentError, "expected #{klass} got #{value.class}" unless value.nil? || value.is_a?(klass)
+          old_value = send("#{name}", :force_reload => true)
+          if value.nil?
+            instance_variable_set("@#{name}", nil)
+          else
+            instance_variable_set("@#{name}", value)
+            value.send("#{self.class.foreign_key}=", id)
+            value.save
+          end
+          
+          if old_value
+            if self.class._find_property(name).options[:dependent] == :destroy
+              old_value.destroy
+            else
+              old_value.send("#{self.class.foreign_property}=", nil)
+              old_value.save
+            end
+          end
+          old_value
+        end
+      end
+      
+      def define_has_one_getter(name)
+        define_method(name) do |*args|
+          options = args.first && args.first.is_a?(Hash) && args.first
+          if options
+            options.assert_valid_keys(:force_reload, :with_deleted)
+            forced_reload = options[:force_reload]
+            with_deleted = options[:with_deleted]
+          else
+            forced_reload = false
+            with_deleted = false
+          end
+
+          if forced_reload || instance_variable_get("@#{name}").nil?
+            instance_variable_set("@#{name}", find_one_associated(name, self.class, :with_deleted => with_deleted))
+          end
+          instance_variable_get("@#{name}")
+        end
+      end
+      
+      class Property
+        attr_reader :name, :options
+      
+        def initialize(owner_clazz, name, options = {})
+          options = {:dependent => :nullify}.update(options)
+          @name, @options = name, options
+          
+          options.assert_valid_keys(:dependent)
+          
+          owner_clazz.class_eval do
+            define_has_one_getter(name)
+            define_has_one_setter(name)
+          end
+        end
+
+        def save(object)
+        end
+
+        def dirty?(object)
+          false
+        end
+
+        def destroy(object)
+        end
+
+        def build(object, json)
+        end
+
+        def serialize(json, object)
+        end
+        
+        def supports_dirty?
+          false
+        end
+        
+        def association?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/simply_stored/couch/validations.rb

@@ -0,0 +1,74 @@
+module SimplyStored
+  module Couch
+    module Validations
+      class ValidatesInclusionOf < ::Validatable::ValidationBase
+        required_option :in
+        option :allow_blank
+        
+        def valid?(instance)
+          if self.allow_blank && instance.send(attribute).blank?
+            true
+          else
+            values = instance.send(attribute)
+            values = [values] unless values.is_a?(Array)
+            values.select{|value|
+              !self.in.include?(value)
+            }.empty?
+          end
+        end
+
+        def message(instance)
+          super || "must be one or more of #{self.in.join(", ")}"
+        end
+      end
+  
+      class ValidatesFormatOf < ::Validatable::ValidationBase #:nodoc:
+        required_option :with
+        option :allow_blank
+
+        def valid?(instance)
+          (allow_blank && instance.send(attribute).blank?) ||
+            !(instance.send(self.attribute).to_s =~ self.with).nil?
+        end
+
+        def message(instance)
+          super || "is invalid"
+        end
+      end
+  
+      class ValidatesUniquenessOf < ::Validatable::ValidationBase
+        def valid?(instance)
+          other_instance = instance.class.send("find_by_#{attribute}", instance.send(attribute))
+          if other_instance && other_instance != instance &&
+              other_instance.send(attribute) == instance.send(attribute)
+            false
+          else
+            true
+          end
+        end
+        
+        def message(instance)
+          super || "#{attribute.to_s.try(:humanize) || attribute.to_s} is already taken"
+        end
+      end
+      
+      def validates_inclusion_of(*args)
+        add_validations(args, ValidatesInclusionOf)
+      end
+      
+      def validates_format_of(*args)
+        add_validations(args, ValidatesFormatOf)
+      end
+      
+      def validates_uniqueness_of(*args)
+        args.each do |name|
+          view "by_#{name}", :key => name
+        end
+        
+        add_validations(args, ValidatesUniquenessOf)
+      end
+    end
+  end
+end
+
+  

data/lib/simply_stored/couch/views/array_property_view_spec.rb

@@ -0,0 +1,22 @@
+module SimplyStored
+  module Couch
+    module Views
+      class ArrayPropertyViewSpec < CouchPotato::View::ModelViewSpec
+        def map_function
+          "function(doc) {
+             if(doc.ruby_class && doc.ruby_class == '#{@klass.name}') {
+               if (#{formatted_key(key)}.constructor.toString().match(/function Array()/)) {
+                 for (var i in #{formatted_key(key)}) {
+                   emit(#{formatted_key(key)}[i], null);
+                 }
+               } else {
+                 emit(#{formatted_key(key)}, null);
+               }
+             }
+           }"
+        end
+
+      end
+    end
+  end
+end

data/lib/simply_stored/couch/views.rb

@@ -0,0 +1 @@
+require 'simply_stored/couch/views/array_property_view_spec'