simply_stored 0.3.9 → 0.5.0

data/CHANGELOG.md

@@ -1,6 +1,44 @@
 Changelog
 =============
 
+0.5.0
+
+- Add support for has_and_belongs_to_many relations:
+
+  n:m relations where the IDs are stored on one part as an array:
+  
+    class Server
+      include SimplyStored::Couch
+
+      property :hostname
+
+      has_and_belongs_to_many :networks, :storing_keys => true
+    end
+
+    class Network
+      include SimplyStored::Couch
+
+      property :klass
+
+      has_and_belongs_to_many :servers, :storing_keys => false
+    end 
+    
+    network = Network.create(:klass => "A")
+    server = Server.new(:hostname => 'www.example.com')
+    network.add_server(server)
+    server.network_ids # => [network.id]
+    network.servers # => [server]
+    server.networks # => [network]
+    
+  The array property holding the IDs of the other item will be used to constuct two view to lookup
+  the other part. Soft deleting is only supported on the class holding the IDs.
+
+- Add support for .last - which is the same as first by reverse order
+
+    User.last # => User.find(:first, :order => :desc)
+
+- Drop support for SimpleDB
+
 0.3.8
 
 - Fix loading of has_many/has_one associations for inherited relations.

data/README.md

@@ -1,11 +1,11 @@
-Convenience layer for CouchDB and SimpleDB. Requires CouchPotato and RightAWS library respectively.
+Convenience layer for CouchDB on top of CouchPotato.
 
-SimplyStored allows you to persist your objects to CouchDB (or SimpleDB) using an ActiveRecord-like syntax.
+SimplyStored allows you to persist your objects to CouchDB using an ActiveRecord-like syntax.
 
 In contrast to [CouchPotato](http://github.com/langalex/couch_potato) (on top of it is build) 
 it supports associations and other syntactic sugar that makes ActiveRecord so appealing. 
 
-Both backends have also support for S3 attachments.
+SimplyStored has also support for S3 attachments.
 
 See also [RockingChair](http://github.com/jweiss/rocking_chair) on how to speed-up your unit tests 
 by using an in-memory CouchDB backend.
@@ -20,25 +20,17 @@ Installation
 Usage
 =============
 
-Require the SimplyStored and decide with backend you want (CouchDB or SimpleDB).
+Require SimplyStored:
 
-    require 'simply_stored/couch'
+    require 'simply_stored'
     CouchPotato::Config.database_name = "http://example.com:5984/name_of_the_db"
-    
-or
-
-    require 'simply_stored/simpledb'
-    SimplyStored::Simple.aws_access_key = 'foo'
-    SimplyStored::Simple.aws_secret_access_key = 'bar'
-    RightAws::ActiveSdb.establish_connection(SimplyStored::Simple.aws_access_key, SimplyStored::Simple.aws_secret_access_key, :protocol => 'https')
-    
+        
 From now on you can define classes that use SimplyStored.
 
-CouchDB - Intro
+Intro
 =============
 
-The CouchDB backend is better supported and has more features. It auto-generates views for you and handles 
-all the serialization and de-serialization stuff.
+SimplyStored auto-generates views for you and handles all the serialization and de-serialization stuff.
 
     class User
       include SimplyStored::Couch
@@ -85,10 +77,10 @@ all the serialization and de-serialization stuff.
     # => []
 
     
-CouchDB - Associations
+Associations
 =============
     
-The supported associations are: belongs_to, has_one, has_many, and has_many :through
+The supported associations are: belongs_to, has_one, has_many, has_many :through, and has_and_belongs_to_many:
     
     class Post
       include SimplyStored::Couch
@@ -136,8 +128,36 @@ The supported associations are: belongs_to, has_one, has_many, and has_many :thr
     post.user_count
     # => 2
     
+  n:m relations where the IDs are stored on one part as an array:
+  
+    class Server
+      include SimplyStored::Couch
+
+      property :hostname
+
+      has_and_belongs_to_many :networks, :storing_keys => true
+    end
+
+    class Network
+      include SimplyStored::Couch
+
+      property :klass
+
+      has_and_belongs_to_many :servers, :storing_keys => false
+    end 
+    
+    network = Network.create(:klass => "A")
+    server = Server.new(:hostname => 'www.example.com')
+    network.add_server(server)
+    server.network_ids # => [network.id]
+    network.servers # => [server]
+    server.networks # => [network]
     
-CouchDB - Custom Associations
+  The array property holding the IDs of the other item will be used to constuct two view to lookup
+  the other part. Soft deleting is only supported on the class holding the IDs.  
+    
+Custom Associations
+=============
 
     class Document
       include SimplyStored::Couch
@@ -150,7 +170,7 @@ CouchDB - Custom Associations
     d.creator = User.first
         
 
-CouchDB - Validations
+Validations
 =============
 
 Further, you can have validations (using the validatable gem)
@@ -181,10 +201,11 @@ Further, you can have validations (using the validatable gem)
     # => raises CouchPotato::Database::ValidationsFailedError: #<CouchPotato::Database::ValidationsFailedError:0x102571130>
     
 
-CouchDB - S3 Attachments
+S3 Attachments
 =============
 
-Both the CouchDB backend and the SimpleDB backend have support for S3 attachments:
+SimplyStored supports storing large attachments in Amazon S3. 
+It uses RightAWS for the interaction with the EC2 API:
 
     class Log
       include SimplyStored::Couch
@@ -205,10 +226,10 @@ Both the CouchDB backend and the SimpleDB backend have support for S3 attachment
     log.data_size
     # => 11238132
     
-This will create an item on S3 in the specified bucket. The item will use the ID of the log object as the key and the body will be the data attribute. This way you can store big files outside of CouchDB or SimpleDB.    
+This will create an item on S3 in the specified bucket. The item will use the ID of the log object as the key and the body will be the data attribute. This way you can store big files outside of CouchDB.    
     
 
-CouchDB - Soft delete
+Soft delete
 =============
     
 SimplyStored also has support for "soft deleting" - much like acts_as_paranoid. Items will then not be deleted but only marked as deleted. This way you can recover them later.

data/lib/simply_stored/couch/association_property.rb

@@ -0,0 +1,27 @@
+module SimplyStored
+  module Couch
+    class AssociationProperty
+      attr_reader :name, :options
+
+      def dirty?(object)
+        false
+      end
+
+      def build(object, json)
+      end
+
+      def serialize(json, object)
+      end
+      alias :value :serialize
+
+      def supports_dirty?
+        false
+      end
+
+      def association?
+        true
+      end
+
+    end
+  end
+end

data/lib/simply_stored/couch/belongs_to.rb

@@ -2,8 +2,11 @@
 module SimplyStored
   module Couch
     module BelongsTo
-      
+      include SimplyStored::Couch::Properties
+
       def belongs_to(name, options = {})
+        check_existing_properties(name, SimplyStored::Couch::BelongsTo::Property)
+
         map_definition_without_deleted = <<-eos
           function(doc) { 
             if (doc['ruby_class'] == '#{self.to_s}' && doc['#{name.to_s}_id'] != null) {
@@ -17,11 +20,6 @@ module SimplyStored
         eos
         
         reduce_definition = "_sum"
-        # reduce_definition = <<-eos
-        #   function(key, values) {
-        #     return sum(values);
-        #   }
-        # eos
          
         view "association_#{self.name.underscore}_belongs_to_#{name}",
           :map => map_definition_without_deleted,
@@ -119,4 +117,4 @@ module SimplyStored
       end
     end
   end
-end
+end

data/lib/simply_stored/couch/finders.rb

@@ -40,7 +40,11 @@ module SimplyStored
       def first(*args)
         find(:first, *args)
       end
-      
+
+      def last(*args)
+        find(:first, :order => :desc, *args)
+      end
+
       def count(options = {})
         options.assert_valid_keys(:with_deleted)
         with_deleted = options[:with_deleted]

data/lib/simply_stored/couch/has_and_belongs_to_many.rb

@@ -0,0 +1,202 @@
+module SimplyStored
+  module Couch
+    module HasAndBelongsToMany
+      def has_and_belongs_to_many(name, options = {})
+        check_existing_properties(name, SimplyStored::Couch::HasAndBelongsToMany::Property)
+        properties << SimplyStored::Couch::HasAndBelongsToMany::Property.new(self, name, options)
+      end
+
+      def define_has_and_belongs_to_many_property(foreign_key)
+        property foreign_key
+      end
+
+      def define_has_and_belongs_to_many_views(name, options)
+        key_order = options[:class_storing_keys] == self.name ? "doc.#{options[:foreign_key]}[index], doc._id" : "doc._id, doc.#{options[:foreign_key]}[index]"
+        value = options[:class_storing_keys] == self.name ? 1 : "{ _id :doc.#{options[:foreign_key]}[index]}"
+
+        map_definition_without_deleted = <<-eos
+          function(doc) {
+            if (doc['ruby_class'] == '#{options[:class_storing_keys]}' && doc['#{options[:foreign_key]}'] != null) {
+              if (doc['#{soft_delete_attribute}'] && doc['#{soft_delete_attribute}'] != null){
+                // "soft" deleted
+              }else{
+                for (var index in doc.#{options[:foreign_key]}) {
+                  emit([#{key_order}], #{value});
+                }
+              }
+            }
+          }
+        eos
+
+        reduce_definition = options[:class_storing_keys] == self.name ? "_sum" : <<-eos
+          function(key, values) {
+            var sum = 0;
+            for (var i in values){
+              if (typeof(i) == 'number'){
+                sum = sum + i;
+              } else {
+                sum = sum + 1;
+              }
+            }
+            return sum;
+          }
+        eos
+
+        view "association_#{self.name.underscore}_has_and_belongs_to_many_#{name}",
+          :map => map_definition_without_deleted,
+          :reduce => reduce_definition,
+          :type => "custom",
+          :include_docs => true
+
+        map_definition_with_deleted = <<-eos
+          function(doc) {
+            if (doc['ruby_class'] == '#{options[:class_storing_keys]}' && doc['#{options[:foreign_key]}'] != null) {
+              for (var index in doc.#{options[:foreign_key]}) {
+                emit([#{key_order}], #{value});
+              }
+            }
+          }
+        eos
+
+        view "association_#{self.name.underscore}_has_and_belongs_to_many_#{name}_with_deleted",
+          :map => map_definition_with_deleted,
+          :reduce => reduce_definition,
+          :type => "custom",
+          :include_docs => true
+      end
+
+      def define_has_and_belongs_to_many_getter(name, options)
+        define_method(name) do |*args|
+          local_options = args.first && args.first.is_a?(Hash) && args.first
+          forced_reload, with_deleted, limit, descending = extract_association_options(local_options)
+
+          cached_results = send("_get_cached_#{name}")
+          cache_key = _cache_key_for(local_options)
+          if forced_reload || cached_results[cache_key].nil?
+            cached_results[cache_key] = find_associated_via_join_view(options[:class_name], self.class, :with_deleted => with_deleted, :limit => limit, :descending => descending, :foreign_key => options[:foreign_key])
+            instance_variable_set("@#{name}", cached_results)
+          end
+          cached_results[cache_key]
+        end
+      end
+
+      def define_has_and_belongs_to_many_setter_add(name, options)
+        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)
+
+          if options[:class_storing_keys] == self.class.name
+            self.send("#{options[:foreign_key]}=", ((send(options[:foreign_key]) || []) + [value.id]).uniq )
+            self.save(false)
+          else
+            value.send("#{options[:foreign_key]}=", ((value.send(options[:foreign_key]) || []) + [self.id]).uniq )
+            value.save(false)
+          end
+
+          cached_results = send("_get_cached_#{name}")[:all]
+          send("_set_cached_#{name}", (cached_results || []) << value, :all)
+          nil
+        end
+      end
+
+      def define_has_and_belongs_to_many_setter_remove(name, options)
+        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)
+
+          if options[:class_storing_keys] == self.class.name
+            raise ArgumentError, "cannot remove not mine" unless (send(options[:foreign_key]) || []).include?(value.id)
+          else
+            raise ArgumentError, "cannot remove not mine" unless (value.send(options[:foreign_key]) || []).include?(id)
+          end
+      
+          if options[:class_storing_keys] == self.class.name
+            foreign_keys = (send(options[:foreign_key]) || []) - [value.id]
+            send("#{options[:foreign_key]}=", foreign_keys)
+            save(false)
+          else
+            foreign_keys = (value.send(options[:foreign_key]) || []) - [self.id]
+            value.send("#{options[:foreign_key]}=", foreign_keys)
+            value.save(false)
+          end
+      
+          cached_results = send("_get_cached_#{name}")[:all]
+          send("_set_cached_#{name}", (cached_results || []).delete_if{|item| item.id == value.id}, :all)
+          nil
+        end
+      end
+      
+      def define_has_and_belongs_to_many_setter_remove_all(name, options)
+        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
+      
+      def define_has_and_belongs_to_many_count(name, options, through = nil)
+        method_name = name.to_s.singularize.underscore + "_count"
+        define_method(method_name) do |*args|
+          local_options = args.first && args.first.is_a?(Hash) && args.first
+          forced_reload, with_deleted, limit, descending = extract_association_options(local_options)
+
+          if forced_reload || instance_variable_get("@#{method_name}").nil?
+            instance_variable_set("@#{method_name}", count_associated_via_join_view(through || options[:class_name], self.class, :with_deleted => with_deleted, :foreign_key => options[:foreign_key]))
+          end
+          instance_variable_get("@#{method_name}")
+        end
+      end
+      
+      def define_has_and_belongs_to_many_after_destroy_cleanup(name, options)
+        if options[:class_storing_keys] == self.name
+          define_method "has_and_belongs_to_many_clean_up_after_destroy" do |property|
+            nil # deleting is enough as we store the keys
+          end
+        else
+          define_method "has_and_belongs_to_many_clean_up_after_destroy" do |property|
+            send("remove_all_#{property.name}")
+          end
+        end
+      end
+
+      class Property < SimplyStored::Couch::AssociationProperty
+
+        def initialize(owner_clazz, name, options = {})
+          options = {
+            :storing_keys => false,
+            :class_name => name.to_s.singularize.camelize,
+            :foreign_key => nil,
+          }.update(options)
+
+          # there is only one pair of foreign_keys and it usualy the name of the class not storing the keys
+          if options[:foreign_key].blank?
+            if options[:storing_keys]
+              options[:foreign_key] = options[:class_name].singularize.underscore.foreign_key.pluralize
+            else
+              options[:foreign_key] = owner_clazz.name.singularize.underscore.foreign_key.pluralize
+            end
+          end
+          options[:class_storing_keys] = options[:storing_keys] ? owner_clazz.name : options[:class_name]
+          @name, @options = name, options
+
+          options.assert_valid_keys(:class_name, :foreign_key, :storing_keys, :class_storing_keys)
+
+          owner_clazz.class_eval do
+            _define_cache_accessors(name, options)
+            define_has_and_belongs_to_many_property(options[:foreign_key]) if options[:storing_keys]
+            define_has_and_belongs_to_many_views(name, options)
+            define_has_and_belongs_to_many_getter(name, options)
+            define_has_and_belongs_to_many_setter_add(name, options)
+            define_has_and_belongs_to_many_setter_remove(name, options)
+            define_has_and_belongs_to_many_setter_remove_all(name, options)
+            define_has_and_belongs_to_many_count(name, options)
+            define_has_and_belongs_to_many_after_destroy_cleanup(name, options)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/simply_stored/couch/has_many.rb

@@ -2,24 +2,14 @@ module SimplyStored
   module Couch
     module HasMany
       def has_many(name, options = {})
+        check_existing_properties(name, SimplyStored::Couch::HasMany::Property)
         properties << SimplyStored::Couch::HasMany::Property.new(self, name, options)
       end
 
       def define_has_many_getter(name, options)
         define_method(name) do |*args|
           local_options = args.first && args.first.is_a?(Hash) && args.first
-          if local_options
-            local_options.assert_valid_keys(:force_reload, :with_deleted, :limit, :order)
-            forced_reload = local_options.delete(:force_reload)
-            with_deleted = local_options[:with_deleted]
-            limit = local_options[:limit]
-            descending = (local_options[:order] == :desc) ? true : false
-          else
-            forced_reload = false
-            with_deleted = false
-            limit = nil
-            descending = false
-          end
+          forced_reload, with_deleted, limit, descending = extract_association_options(local_options)
 
           cached_results = send("_get_cached_#{name}")
           cache_key = _cache_key_for(local_options)
@@ -131,22 +121,6 @@ module SimplyStored
         end
       end
       
-      def define_cache_accessors(name, options)
-        define_method "_get_cached_#{name}" do
-          instance_variable_get("@#{name}") || {}
-        end
-        
-        define_method "_set_cached_#{name}" do |value, cache_key|
-          cached = send("_get_cached_#{name}")
-          cached[cache_key] = value
-          instance_variable_set("@#{name}", cached)
-        end
-        
-        define_method "_cache_key_for" do |opt|
-          opt.blank? ? :all : opt.to_s
-        end
-      end
-      
       def set_parent_has_many_association_object(parent, child_collection)
         child_collection.each do |child|
           if child.respond_to?("#{parent.class.name.to_s.singularize.downcase}=")
@@ -155,8 +129,7 @@ module SimplyStored
         end
       end
       
-      class Property
-        attr_reader :name, :options
+      class Property < SimplyStored::Couch::AssociationProperty
         
         def initialize(owner_clazz, name, options = {})
           options = {
@@ -171,13 +144,13 @@ module SimplyStored
           
           if options[:through]
             owner_clazz.class_eval do
-              define_cache_accessors(name, options)
+              _define_cache_accessors(name, options)
               define_has_many_through_getter(name, options, options[:through])
               define_has_many_count(name, options, options[:through])
             end
           else
             owner_clazz.class_eval do
-              define_cache_accessors(name, options)
+              _define_cache_accessors(name, options)
               define_has_many_getter(name, options)
               define_has_many_setter_add(name, options)
               define_has_many_setter_remove(name, options)
@@ -187,25 +160,7 @@ module SimplyStored
           end
         end
         
-        def dirty?(object)
-          false
-        end
-
-        def build(object, json)
-        end
-
-        def serialize(json, object)
-        end
-        alias :value :serialize
-        
-        def supports_dirty?
-          false
-        end
-        
-        def association?
-          true
-        end
       end
     end
   end
-end
+end

data/lib/simply_stored/couch/has_one.rb

@@ -2,6 +2,7 @@ module SimplyStored
   module Couch
     module HasOne
       def has_one(name, options = {})
+        check_existing_properties(name, SimplyStored::Couch::HasOne::Property)
         properties << SimplyStored::Couch::HasOne::Property.new(self, name, options)
       end
       
@@ -33,14 +34,7 @@ module SimplyStored
       def define_has_one_getter(name, options)
         define_method(name) do |*args|
           local_options = args.first && args.first.is_a?(Hash) && args.first
-          if local_options
-            local_options.assert_valid_keys(:force_reload, :with_deleted)
-            forced_reload = local_options[:force_reload]
-            with_deleted = local_options[:with_deleted]
-          else
-            forced_reload = false
-            with_deleted = false
-          end
+          forced_reload, with_deleted, limit, descending = extract_association_options(local_options)
 
           if forced_reload || instance_variable_get("@#{name}").nil?
             found_object = find_one_associated(options[:class_name], self.class, :with_deleted => with_deleted, :foreign_key => options[:foreign_key])
@@ -57,8 +51,7 @@ module SimplyStored
         end
       end
       
-      class Property
-        attr_reader :name, :options
+      class Property < SimplyStored::Couch::AssociationProperty
       
         def initialize(owner_clazz, name, options = {})
           options = {
@@ -76,25 +69,7 @@ module SimplyStored
           end
         end
 
-        def dirty?(object)
-          false
-        end
-
-        def build(object, json)
-        end
-
-        def serialize(json, object)
-        end
-        alias :value :serialize
-        
-        def supports_dirty?
-          false
-        end
-        
-        def association?
-          true
-        end
       end
     end
   end
-end
+end

data/lib/simply_stored/couch/properties.rb

@@ -0,0 +1,11 @@
+module SimplyStored
+  module Couch
+    module Properties
+      def check_existing_properties(name, type)
+        if properties.find{|property| name.to_sym == property.name.to_sym && property.class != type}
+          raise "Property with the name (#{name}) already defined"
+        end
+      end
+    end
+  end
+end