acts-as-joinable 0.2 → 0.2.2

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/gempackagetask'
 spec = Gem::Specification.new do |s|
   s.name              = "acts-as-joinable"
   s.authors           = ["Lance Pollard"]
-  s.version           = "0.2"
+  s.version           = "0.2.2"
   s.summary           = "ActsAsJoinable: DRYing up Many-to-Many Relationships in ActiveRecord"
   s.homepage          = "http://github.com/viatropos/acts-as-joinable"
   s.email             = "lancejpollard@gmail.com"

data/lib/acts-as-joinable.rb

@@ -41,6 +41,7 @@ module ActsAsJoinable
           end
           
           include ActsAsJoinable::Core
+          include ActsAsJoinable::Dirty
         end
       end
     end

data/lib/acts_as_joinable/core.rb

@@ -1,3 +1,5 @@
+# http://github.com/pluginaweek/preferences/blob/master/lib/preferences.rb
+# add changes so you can track when the join model changes
 module ActsAsJoinable
   module Core
     def self.included(base)
@@ -8,7 +10,21 @@ module ActsAsJoinable
     end
     
     module ClassMethods
-      
+      def add_around_filters_for_join(options, attribute, filter, filter_type)
+        options[filter_type] = filter if filter
+=begin
+        if filter          
+          options[filter_type]    = lambda { |parent, child|
+            parent.write_join_attribute(attribute, child.id)
+            filter.call(self)
+          }
+        else
+          options[filter_type]    = lambda { |parent, child|
+            parent.write_join_attribute(attribute, child.id)
+          }
+        end
+=end
+      end
       # custom parent, self, and child contexts
       # Group...
       #   acts_as_joinable_on :groups,
@@ -59,6 +75,8 @@ module ActsAsJoinable
         
         scope_name  = opts[:named_scope]
         
+        autosave = opts[:autosave] != false
+        
         joins.map!(&:to_sym)
         
         # class name of the model we're joining to self
@@ -110,8 +128,8 @@ module ActsAsJoinable
             :conditions           => sql
           }
           
-          options[:before_add] = before_add if before_add
-          options[:after_add] = after_add if after_add
+          add_around_filters_for_join(options, "#{singular_type.to_s}_id".to_sym, before_add, :before_add)
+          add_around_filters_for_join(options, "#{singular_type.to_s}_id".to_sym, after_add, :after_add)
           
           # relationships == [:parent, :child]
           relationships.each do |relationship|
@@ -275,16 +293,13 @@ module ActsAsJoinable
       
       def add_has_one(singular_type, plural_type, relationship_with_context, class_name, join_context, join_value, options)
         define_method singular_type do
-          send(plural_type).last
+          send(plural_type)[-1]#.last
         end
         define_method "#{singular_type}=" do |value|
-          #send(relationship_with_context).delete_all
+          return value if send(plural_type).map(&:id).include?(value.id)
           
-          #send(relationship_with_context).delete_all
+          send(plural_type) << value unless value.blank?
           
-          unless value.blank?
-            send(plural_type) << value
-          end
           if value.blank?
             send(plural_type).delete_all
           else
@@ -337,6 +352,10 @@ module ActsAsJoinable
     end
     
     module InstanceMethods
+      def write_join_attribute(name, value)
+        
+      end
+      
       def destroy_relationships
         #conditions = %Q|(`relationships`.parent_type IN ("#{self.class.name}","#{self.class.base_class.name}") AND `relationships`.parent_id = #{self.id}) OR (`relationships`.child_type IN ("#{self.class.name}","#{self.class.base_class.name}") AND `relationships`.child_id = #{self.id})|
         classes = [self.class.name, self.class.base_class.name].compact.uniq

data/lib/acts_as_joinable/dirty.rb

@@ -0,0 +1,116 @@
+module ActsAsJoinable
+  module Dirty
+    def self.included(base)
+      base.extend ClassMethods
+      base.send :include, InstanceMethods
+    end
+    
+    module ClassMethods
+      
+    end
+    
+    module InstanceMethods
+      def write_join_attribute(name, value, context = nil)
+        name = name.to_s
+        assert_valid_join_attribute(name)
+        
+        join_attributes_changed = join_attributes_changed_context(context)
+
+        if join_attributes_changed.include?(name)
+          old = join_attributes_changed[name]
+          join_attributes_changed.delete(name) unless join_attribute_value_changed?(name, old, value)
+        else
+          old = clone_join_attribute_value(name, context)
+          join_attributes_changed[name] = old if join_attribute_value_changed?(name, old, value)
+        end
+
+        join_attributes_context(context)[name] = value
+
+        value
+      end
+
+      def join_attributes_changed?(context = nil)
+        !join_attributes_changed_context(context).empty?
+      end
+
+      def join_attributes_changed(context = nil)
+        join_attributes_changed_context(context).keys
+      end
+
+      def join_attribute_changes(context = nil)
+        join_attributes_changed(context).inject({}) do |changes, join_attribute|
+          changes[join_attribute] = join_attribute_change(join_attribute, context)
+          changes
+        end
+      end
+
+      def reload(*args) #:nodoc:
+        result = super
+
+        @join_attributes.clear if @join_attributes
+        @join_attributes_changed.clear if @join_attributes_changed
+
+        result
+      end
+      
+      private
+      
+      def assert_valid_join_attribute(name)
+        #raise(ArgumentError, "Unknown join_attribute: #{name}") unless join_attribute_definitions.include?(name)
+      end
+
+      def join_attributes_context(context)
+        @join_attributes ||= {}
+        @join_attributes[context.is_a?(Symbol) ? context.to_s : context] ||= {}
+      end
+
+      def join_attributes_context_loaded?(context)
+        true #join_attribute_definitions.length == join_attributes_context(context).length
+      end
+
+      # Generates a clone of the current value stored for the join_attribute with
+      # the given name / context
+      def clone_join_attribute_value(name, context)
+        value = join_attribute(name, context)
+        value.duplicable? ? value.clone : value
+      rescue TypeError, NoMethodError
+        value
+      end
+      
+      def join_attribute(name, context = nil)
+        join_attributes_context(context)[name]
+      end
+
+      # Keeps track of all join_attributes that have been changed so that they can
+      # be properly updated in the database.  Maps context -> join_attribute -> value.
+      def join_attributes_changed_context(context)
+        @join_attributes_changed ||= {}
+        @join_attributes_changed[context.is_a?(Symbol) ? context.to_s : context] ||= {}
+      end
+
+      def join_attribute_changed?(name, context)
+        join_attributes_changed_context(context).include?(name)
+      end
+
+      def join_attribute_change(name, context)
+        [join_attributes_changed_context(context)[name], join_attribute(name, context)] if join_attribute_changed?(name, context)
+      end
+
+      def join_attribute_was(name, context)
+        join_attribute_changed?(name, context) ? join_attributes_changed_context(context)[name] : join_attribute(name, context)
+      end
+
+      def join_attribute_will_change!(name, context)
+        join_attributes_changed_context(context)[name] = clone_join_attribute_value(name, context)
+      end
+
+      def reset_join_attribute!(name, context)
+        write_join_attribute(name, join_attributes_changed_context(context)[name], context) if join_attribute_changed?(name, context)
+      end
+
+      def join_attribute_value_changed?(name, old, value)
+        old != value
+      end
+    end
+  end
+end

data/test/test_acts_as_joinable.rb

@@ -78,7 +78,7 @@ class ActsAsJoinableTest < ActiveRecord::TestCase
         end
         
         # parent, child, and self
-        assert_queries(2) do
+        assert_queries(3) do
           group.destroy
         end
         
@@ -93,6 +93,22 @@ class ActsAsJoinableTest < ActiveRecord::TestCase
         
       end
       
+      context "dirty join attributes" do
+        setup do
+          Group.delete_all
+          @group = Group.create!
+        end
+        
+        should "get dirty attributes" do
+          assert !@group.join_attributes_changed?
+          
+          @group.posts << Post.create!
+          
+          assert @group.join_attributes_changed?
+          puts @group.join_attribute_changes.inspect
+        end
+      end
+      
       teardown do
         destroy_models
       end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: acts-as-joinable
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 19
   prerelease: false
   segments: 
   - 0
   - 2
-  version: "0.2"
+  - 2
+  version: 0.2.2
 platform: ruby
 authors: 
 - Lance Pollard
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-22 00:00:00 -05:00
+date: 2010-10-26 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -34,6 +35,7 @@ files:
 - lib/acts-as-joinable.rb
 - lib/acts_as_joinable/active_record_patch.rb
 - lib/acts_as_joinable/core.rb
+- lib/acts_as_joinable/dirty.rb
 - rails/init.rb
 - test/database.rb
 - test/lib/asset.rb