has_and_belongs_to_many_with_deferred_save 0.1.0

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/Rakefile

@@ -0,0 +1,23 @@
+task :default do |t|
+  options = "--colour"
+  files = FileList['spec/**/*_spec.rb'].map{|f| f.sub(%r{^spec/},'') }
+  exit system("cd spec && spec #{options} #{files}") ? 0 : 1
+end
+
+begin
+  require 'jeweler'
+  project_name = 'has_and_belongs_to_many_with_deferred_save'
+  Jeweler::Tasks.new do |gem|
+    gem.name = project_name
+    gem.summary = "Make ActiveRecord defer/postpone saving the records you add to an habtm (has_and_belongs_to_many) association until you call model.save, allowing validation in the style of normal attributes."
+    gem.email = "github.com@tylerrick.com"
+    gem.homepage = "http://github.com/TylerRick/has_and_belongs_to_many_with_deferred_save"
+    gem.authors = ["Tyler Rick", "Alessio Caiazza"]
+    gem.add_dependency('activerecord')
+    gem.add_development_dependency('rspec')
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/Readme.markdown

@@ -0,0 +1,60 @@
+Make ActiveRecord defer/postpone saving the records you add to an habtm (has_and_belongs_to_many) association until you call model.save, allowing validation in the style of normal attributes.
+
+How to install
+==============
+
+As Rails plugin:
+    ./script/plugin install git://github.com/TylerRick/has_and_belongs_to_many_with_deferred_save.git
+
+As a gem:
+    sudo gem install has_and_belongs_to_many_with_deferred_save
+
+Usage
+=====
+
+    class Room < ActiveRecord::Base
+      has_and_belongs_to_many_with_deferred_save :people
+    end
+
+Motivation
+==========
+
+Let's say you want to validate the room.people collection and prevent the user from adding more people to the room than will fit. If they do try to add more people than will fit, you want to display a nice error message on the page and let them try again...
+
+This isn't possible using the standard has_and_belongs_to_many due to these two problems:
+
+1. When we do the assignment to our collection (room.people = whatever), it immediately saves it in our join table (people_rooms) rather than waiting until we call room.save.
+
+2. You can "validate" using habtm's :before_add option ... but it any errors added there end up being ignored/lost. The only way to abort the save from a before_add seems to be to raise an exception... 
+
+But we don't want to raise an exception when the user violates our validation; we want validation of the people collection to be handled the same as any other field in the Room model: we want it to simply add an error to the Room model's error array which we can than display on the form with the other input errors.
+
+has_and_belongs_to_many_with_deferred_save solves this problem by overriding the setter method for your collection (people=), causing it to store the new members in a temporary variable (unsaved_people) rather than saving it immediately.
+
+You can then validate the unsaved collection as you would any other attribute, adding to self.errors if something is invalid about the collection (too many members, etc.).
+
+The unsaved collection is automatically saved when you call save on the model.
+
+
+Compatibility
+=============
+
+Tested with Rails 2.3.4.
+
+Bugs
+====
+
+http://github.com/TylerRick/has_and_belongs_to_many_with_deferred_save/issues
+
+History
+=======
+
+It started as a [post](http://www.ruby-forum.com/topic/81095) to the Rails mailing list asking how to validate a has_and_belongs_to_many collection/association.
+
+License
+=======
+
+This plugin is licensed under the BSD license.
+
+2010 (c) Contributors
+2007 (c) QualitySmith, Inc.

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/has_and_belongs_to_many_with_deferred_save.gemspec

@@ -0,0 +1,61 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{has_and_belongs_to_many_with_deferred_save}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tyler Rick", "Alessio Caiazza"]
+  s.date = %q{2010-02-25}
+  s.email = %q{github.com@tylerrick.com}
+  s.files = [
+    ".gitignore",
+     "Rakefile",
+     "Readme.markdown",
+     "VERSION",
+     "has_and_belongs_to_many_with_deferred_save.gemspec",
+     "init.rb",
+     "install.rb",
+     "lib/has_and_belongs_to_many_with_deferred_save.rb",
+     "spec/.gitignore",
+     "spec/db/database.yml",
+     "spec/db/schema.rb",
+     "spec/has_and_belongs_to_many_with_deferred_save_spec.rb",
+     "spec/models/person.rb",
+     "spec/models/room.rb",
+     "spec/spec_helper.rb",
+     "uninstall.rb"
+  ]
+  s.homepage = %q{http://github.com/TylerRick/has_and_belongs_to_many_with_deferred_save}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Make ActiveRecord defer/postpone saving the records you add to an habtm (has_and_belongs_to_many) association until you call model.save, allowing validation in the style of normal attributes.}
+  s.test_files = [
+    "spec/models/room.rb",
+     "spec/models/person.rb",
+     "spec/has_and_belongs_to_many_with_deferred_save_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/db/schema.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end
+

data/init.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'lib/has_and_belongs_to_many_with_deferred_save')

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/has_and_belongs_to_many_with_deferred_save.rb

@@ -0,0 +1,133 @@
+# To do: make it work to call this twice in a class. Currently that probably wouldn't work, because it would try to alias methods to existing names...
+# Note: before_save must be defined *before* including this module, not after.
+
+module ActiveRecord
+  module Associations
+    module ClassMethods
+      # Instructions:
+      #
+      # Replace your existing call to has_and_belongs_to_many with has_and_belongs_to_many_with_deferred_save.
+      #
+      # Then add a validation method that adds an error if there is something wrong with the (unsaved) collection. This will prevent it from being saved if there are any errors.
+      #
+      # Example:
+      #
+      #  def validate
+      #    if people.size > maximum_occupancy
+      #      errors.add :people, "There are too many people in this room"
+      #    end
+      #  end
+      def has_and_belongs_to_many_with_deferred_save(*args)
+        has_and_belongs_to_many *args
+        collection_name = args[0].to_s
+        collection_singular_ids = collection_name.singularize + "_ids"
+        
+        # this will delete all the assocation into the join table after obj.destroy
+        after_destroy { |record| record.save }
+
+        attr_accessor :"unsaved_#{collection_name}"
+        attr_accessor :"use_original_collection_reader_behavior_for_#{collection_name}"
+
+        define_method "#{collection_name}_with_deferred_save=" do |collection|
+          #puts "has_and_belongs_to_many_with_deferred_save: #{collection_name} = #{collection.collect(&:id).join(',')}"
+          self.send "unsaved_#{collection_name}=", collection
+        end
+
+        define_method "#{collection_name}_with_deferred_save" do |*args|
+          if self.send("use_original_collection_reader_behavior_for_#{collection_name}")
+            self.send("#{collection_name}_without_deferred_save")
+          else
+            if self.send("unsaved_#{collection_name}").nil?
+              send("initialize_unsaved_#{collection_name}", *args)
+            end
+            self.send("unsaved_#{collection_name}")
+          end
+        end
+
+        alias_method_chain :"#{collection_name}=", 'deferred_save'
+        alias_method_chain :"#{collection_name}", 'deferred_save'
+
+        define_method "#{collection_singular_ids}_with_deferred_save" do |*args|
+          if self.send("use_original_collection_reader_behavior_for_#{collection_name}")
+            self.send("#{collection_singular_ids}_without_deferred_save")
+          else
+            if self.send("unsaved_#{collection_name}").nil?
+              send("initialize_unsaved_#{collection_name}", *args)
+            end
+            self.send("unsaved_#{collection_name}").map { |e| e[:id] }
+          end
+        end
+
+        alias_method_chain :"#{collection_singular_ids}", 'deferred_save'
+
+
+        define_method "before_save_with_deferred_save_for_#{collection_name}" do
+          # Question: Why do we need this @use_original_collection_reader_behavior stuff?
+          # Answer: Because AssociationCollection#replace(other_array) performs a diff between current_array and other_array and deletes/adds only 
+          # records that have changed.
+          # In order to perform that diff, it needs to figure out what "current_array" is, so it calls our collection_with_deferred_save, not 
+          # knowing that we've changed its behavior. It expects that method to return the elements of that collection that are in the *database*
+          # (the original behavior), so we have to provide that behavior...  If we didn't provide it, it would end up trying to take the diff of
+          # two identical collections so nothing would ever get saved.
+          # But we only want the old behavior in this case -- most of the time we want the *new* behavior -- so we use 
+          # @use_original_collection_reader_behavior as a switch.
+          
+          if self.respond_to? :"before_save_without_deferred_save_for_#{collection_name}"
+            self.send("before_save_without_deferred_save_for_#{collection_name}") 
+          end  
+
+          self.send "use_original_collection_reader_behavior_for_#{collection_name}=", true
+          if self.send("unsaved_#{collection_name}").nil?
+            send("initialize_unsaved_#{collection_name}", *args)
+          end
+          self.send "#{collection_name}_without_deferred_save=", self.send("unsaved_#{collection_name}")
+            # /\ This is where the actual save occurs.
+          self.send "use_original_collection_reader_behavior_for_#{collection_name}=", false
+
+          true
+        end
+        alias_method_chain :"before_save", "deferred_save_for_#{collection_name}"
+
+
+        define_method "reload_with_deferred_save_for_#{collection_name}" do
+          # Reload from the *database*, discarding any unsaved changes.
+          returning self.send("reload_without_deferred_save_for_#{collection_name}") do
+            self.send "unsaved_#{collection_name}=", nil
+              # /\ If we didn't do this, then when we called reload, it would still have the same (possibly invalid) value of
+              # unsaved_collection that it had before the reload.
+          end
+        end
+        alias_method_chain :"reload", "deferred_save_for_#{collection_name}"
+
+
+        define_method "initialize_unsaved_#{collection_name}" do |*args|
+          #puts "Initialized to #{self.send("#{collection_name}_without_deferred_save").clone.inspect}"
+          self.send "unsaved_#{collection_name}=", self.send("#{collection_name}_without_deferred_save", *args).clone
+            # /\ We initialize it to collection_without_deferred_save in case they just loaded the object from the 
+            # database, in which case we want unsaved_collection to start out with the "saved collection".
+            # If they just constructed a *new* object, this will still work, because self.collection_without_deferred_save.clone 
+            # will return a new HasAndBelongsToManyAssociation (which acts like an empty array, []).
+            # Important: If we don't use clone, then it does an assignment by reference and any changes to unsaved_collection
+            # will also change *collection_without_deferred_save*! (Not what we want! Would result in us saving things
+            # immediately, which is exactly what we're trying to avoid.)
+          
+          # trick collection_name.include?(obj)
+          # If you use a collection of SignelTableInheritance and didn't :select 'type' the
+          # include? method will not find any subclassed object.
+          class << eval("@unsaved_#{collection_name}")
+            def include_with_deferred_save?(obj)
+              if self.find { |itm| itm == obj || (itm[:id] == obj[:id] && obj.is_a?(itm.class) ) }
+                return true
+              else
+                return false
+              end
+            end
+            alias_method_chain :include?, 'deferred_save'
+          end
+        end
+        private :"initialize_unsaved_#{collection_name}"
+        
+      end
+    end
+  end
+end

data/spec/.gitignore

@@ -0,0 +1,2 @@
+*.log
+*.db

data/spec/db/database.yml

@@ -0,0 +1,21 @@
+sqlite3:
+  adapter: sqlite3
+  database: test.sqlite3.db
+
+sqlite3mem:
+  adapter: sqlite3
+  database: ":memory:"
+
+postgresql:
+  adapter: postgresql
+  username: postgres
+  password: postgres
+  database: has_and_belongs_to_many_with_deferred_save_test
+  min_messages: ERROR
+
+mysql:
+  adapter: mysql
+  host: localhost
+  username: root
+  password:
+  database: has_and_belongs_to_many_with_deferred_save_test

data/spec/db/schema.rb

@@ -0,0 +1,21 @@
+# This file is autogenerated. Instead of editing this file, please use the
+# migrations feature of ActiveRecord to incrementally modify your database, and
+# then regenerate this schema definition.
+
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table "people", :force => true do |t|
+    t.column "name", :string
+  end
+
+  create_table "people_rooms", :id => false, :force => true do |t|
+    t.column "person_id", :integer
+    t.column "room_id",   :integer
+  end
+
+  create_table "rooms", :force => true do |t|
+    t.column "name",              :string
+    t.column "maximum_occupancy", :integer
+  end
+
+end

data/spec/has_and_belongs_to_many_with_deferred_save_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+require 'has_and_belongs_to_many_with_deferred_save'
+
+describe "has_and_belongs_to_many_with_deferred_save" do
+  describe "room maximum_occupancy" do
+    before :all do
+      @people = []
+      @people << Person.create
+      @people << Person.create
+      @people << Person.create
+      @room = Room.new(:maximum_occupancy => 2)
+    end
+
+    it "initial checks" do
+      Room  .count.should == 0
+      Person.count.should == 3
+
+      @room.people.should == []
+      @room.people_without_deferred_save.should == []
+      @room.people_without_deferred_save.object_id.should_not ==
+        @room.unsaved_people.object_id
+    end
+
+    it "after adding people to room, it should not have saved anything to the database" do
+      @room.people << @people[0]
+      @room.people << @people[1]
+
+      # Still not saved to the association table!
+      Room.count_by_sql("select count(*) from people_rooms").should == 0
+      @room.people_without_deferred_save.size.               should == 0
+    end
+
+    it "but room.people.size should still report the current size of 2" do
+      @room.people.size.should == 2        # 2 because this looks at unsaved_people and not at the database
+    end
+
+    it "after saving the model, the association should be saved in the join table" do
+      @room.save    # Only here is it actually saved to the association table!
+      @room.errors.full_messages.should == []
+      Room.count_by_sql("select count(*) from people_rooms").should == 2
+      @room.people.size.                                     should == 2
+      @room.people_without_deferred_save.size.               should == 2
+    end
+
+    it "when we try to add a 3rd person, it should add a validation error to the errors object like any other validation error" do
+      lambda { @room.people << @people[2] }.should_not raise_error
+      @room.people.size.       should == 3
+
+      Room.count_by_sql("select count(*) from people_rooms").should == 2
+      @room.valid?
+      @room.errors.on(:people).should == "There are too many people in this room"
+      @room.people.size.       should == 3 # Just like with normal attributes that fail validation... the attribute still contains the invalid data but we refuse to save until it is changed to something that is *valid*.
+    end
+
+    it "when we try to save, it should fail, because room.people is still invaild" do
+      @room.save.should == false
+      Room.count_by_sql("select count(*) from people_rooms").should == 2 # It's still not there, because it didn't pass the validation.
+      @room.errors.on(:people).should == "There are too many people in this room"
+      @room.people.size.       should == 3
+    end
+
+    it "when we reload, it should go back to only having 2 people in the room" do
+      @room.reload
+      @room.people.size.                                     should == 2
+      @room.people_without_deferred_save.size.               should == 2
+    end
+
+    it "if they try to go around our accessors and use the original accessors, then (and only then) will the exception be raised in before_adding_person..." do
+      lambda do
+        @room.people_without_deferred_save << @people[2]
+      end.should raise_error(RuntimeError)
+    end
+  end
+end

data/spec/models/person.rb

@@ -0,0 +1,3 @@
+class Person < ActiveRecord::Base
+  has_and_belongs_to_many :room
+end

data/spec/models/room.rb

@@ -0,0 +1,17 @@
+class Room < ActiveRecord::Base
+  has_and_belongs_to_many_with_deferred_save :people, :before_add => :before_adding_person
+
+  def validate
+    if people.size > maximum_occupancy
+      errors.add :people, "There are too many people in this room"
+    end
+  end
+
+  # Just in case they try to bypass our new accessor and call people_without_deferred_save directly...
+  # (This should never be necessary; it is for demonstration purposes only...)
+  def before_adding_person(person)
+    if self.people_without_deferred_save.size + [person].size > maximum_occupancy
+      raise "There are too many people in this room"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+plugin_test_dir = File.dirname(__FILE__)
+
+#require 'multi_rails_init'
+require 'active_record'
+# Workaround for https://rails.lighthouseapp.com/projects/8994/tickets/2577-when-using-activerecordassociations-outside-of-rails-a-nameerror-is-thrown
+ActiveRecord::ActiveRecordError
+
+require plugin_test_dir + '/../init.rb'
+
+ActiveRecord::Base.logger = Logger.new(plugin_test_dir + "/test.log")
+
+ActiveRecord::Base.configurations = YAML::load(IO.read(plugin_test_dir + "/db/database.yml"))
+ActiveRecord::Base.establish_connection(ENV["DB"] || "sqlite3")
+ActiveRecord::Migration.verbose = false
+load(File.join(plugin_test_dir, "db", "schema.rb"))
+
+Dir["#{plugin_test_dir}/models/*.rb"].each {|file| require file }
+
+Spec::Runner.configure do |config|
+  config.before do
+  end
+end

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: has_and_belongs_to_many_with_deferred_save
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Tyler Rick
+- Alessio Caiazza
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-25 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: github.com@tylerrick.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Rakefile
+- Readme.markdown
+- VERSION
+- has_and_belongs_to_many_with_deferred_save.gemspec
+- init.rb
+- install.rb
+- lib/has_and_belongs_to_many_with_deferred_save.rb
+- spec/.gitignore
+- spec/db/database.yml
+- spec/db/schema.rb
+- spec/has_and_belongs_to_many_with_deferred_save_spec.rb
+- spec/models/person.rb
+- spec/models/room.rb
+- spec/spec_helper.rb
+- uninstall.rb
+has_rdoc: true
+homepage: http://github.com/TylerRick/has_and_belongs_to_many_with_deferred_save
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Make ActiveRecord defer/postpone saving the records you add to an habtm (has_and_belongs_to_many) association until you call model.save, allowing validation in the style of normal attributes.
+test_files: 
+- spec/models/room.rb
+- spec/models/person.rb
+- spec/has_and_belongs_to_many_with_deferred_save_spec.rb
+- spec/spec_helper.rb
+- spec/db/schema.rb