mover 0.1.1 → 0.2.0

data/README.markdown

@@ -10,86 +10,61 @@ Requirements
 sudo gem install mover
 </pre>
 
-<a name="create_the_movable_table"></a>
-
-Create the movable table
-------------------------
-
-Migration:
+Move records
+------------
 
 <pre>
-class CreateArticlesArchive < ActiveRecord::Migration
-  def self.up
-    Article.create_movable_table(
-      :archive,
-      :columns => %w(id title body created_at),
-      :indexes => %w(id created_at)
-    )
-    add_column :articles_archive, :move_id, :string
-    add_column :articles_archive, :moved_at, :datetime
-  end
-
-  def self.down
-    Article.drop_movable_table(:archive)
-  end
-end
+Article.last.move_to(ArticleArchive)
+Article.move_to(ArticleArchive, [ "created_at > ?", Date.today ])
 </pre>
 
-The first parameter names your movable table. In this example, the table is named <code>articles_archive</code>.
-
-Options:
+The <code>move_to</code> method is available to all models.
 
-* <code>:columns</code> - Only use certain columns from the original table. Defaults to all.
-* <code>:indexes</code> - Only create certain indexes. Defaults to all.
+The two tables do not have to be identical. Only shared columns transfer.
 
-We also added two columns, <code>move\_id</code> and <code>moved\_at</code>. These are <a href="#magic_columns">magic columns</a>.
+Callbacks
+---------
 
-<a name="define_the_model"></a>
+In this example, we want an "archive" table for articles and comments.
 
-Define the model
-----------------
+We also want the article's comments to be archived when the article is.
 
 <pre>
 class Article < ActiveRecord::Base
-  is_movable :archive
+  has_many :comments
+  before_move_to :ArticleArchive do
+    comments.each { |c| c.move_to(CommentArchive) }
+  end
 end
-</pre>
 
-The <code>is_movable</code> method takes any number of parameters for multiple movable tables.
+class ArticleArchive < ActiveRecord::Base
+  has_many :comments, :class_name => 'CommentArchive', :foreign_key => 'article_id'
+  before_move_to :Article do
+    comments.each { |c| c.move_to(Comment) }
+  end
+end
 
-Moving records
---------------
+class Comment < ActiveRecord::Base
+  belongs_to :article
+end
 
-<pre>
-Article.last.move_to(:archive)
-Article.move_to(:archive, [ "created_at > ?", Date.today ])
+class CommentArchive < ActiveRecord::Base
+  belongs_to :article, :class_name => 'ArticleArchive', :foreign_key => 'article_id'
+end
 </pre>
 
-Associations move if they are movable and if all movable tables have a <code>move_id</code> column (see <a href="#magic_columns">magic columns</a>).
+Reserve a spot
+--------------
 
-Restoring records
------------------
+Before you create a record, you can "reserve a spot" on a table that you will move the record to later.
 
 <pre>
-Article.move_from(:archive, [ "created_at > ?", Date.today ])
-ArticleArchive.last.move_from
+ArticleArchive.create(:id => Article.reserve_id)
 </pre>
 
-You can access the movable table by prepending its name to the original class name. In this example, you would use <code>ArticleArchive</code>.
-
-<a name="magic_columns"></a>
-
 Magic columns
 -------------
 
-### move_id
-
-By default, restoring a record will only restore itself and not its movable relationships.
-
-To restore the relationships automatically, add the <code>move_id</code> column to all movable tables involved.
-
 ### moved_at
 
-If you need to know when the record was moved, add the <code>moved\_at</code> column to your movable table.
-
-See the <a href="#create_the_movable_table">create the movable table</a> section for an example of how to add the magic columns.
+If a table contains the column <code>moved_at</code>, it will automatically be populated with the date and time it was moved.

data/lib/mover.rb

@@ -2,68 +2,87 @@ require File.expand_path("#{File.dirname(__FILE__)}/../require")
 Require.lib!
 
 module Mover
-  module Base
-    def self.included(base)
-      unless base.included_modules.include?(Included)
-        base.extend ClassMethods
-        base.send :include, Included
-      end
+  def self.included(base)
+    unless base.included_modules.include?(InstanceMethods)
+      base.extend ClassMethods
+      base.send :include, InstanceMethods
     end
+  end
   
-    module ClassMethods
-      def is_movable(*types)
-        @movable_types = types
-        
-        self.class_eval do
-          attr_accessor :movable_id
-          class <<self
-            attr_reader :movable_types
-          end
+  module ClassMethods
+    
+    def after_move_to(to_class, &block)
+      @after_move_to ||= []
+      @after_move_to << [ to_class, block ]
+    end
+    
+    def before_move_to(to_class, &block)
+      @before_move_to ||= []
+      @before_move_to << [ to_class, block ]
+    end
+    
+    def move_to(to_class, conditions, instance=nil)
+      from_class = self
+      # Conditions
+      add_conditions! where = '', conditions
+      # Columns
+      insert = from_class.column_names & to_class.column_names
+      insert -= [ 'moved_at' ]
+      insert.collect! { |col| connection.quote_column_name(col) }
+      select = insert.clone
+      # Magic columns
+      if to_class.column_names.include?('moved_at')
+        insert << connection.quote_column_name('moved_at')
+        select << connection.quote(Time.now.utc)
+      end
+      # Callbacks
+      collector = lambda { |(klass, block)| block if eval(klass.to_s) == to_class }
+      before = (@before_move_to || []).collect(&collector).compact
+      after = (@after_move_to || []).collect(&collector).compact
+      # Instances
+      instances =
+        if instance
+          [ instance ]
+        elsif before.empty? && after.empty?
+          []
+        else
+          self.find(:all, :conditions => where[5..-1])
         end
-        
-        types.each do |type|
-          eval <<-RUBY
-            class ::#{self.name}#{type.to_s.classify} < ActiveRecord::Base
-              include Mover::Base::Record::InstanceMethods
-              
-              self.table_name = "#{self.table_name}_#{type}"
-              
-              def self.movable_type
-                #{type.inspect}
-              end
-              
-              def moved_from_class
-                #{self.name}
-              end
-            end
-          RUBY
+      # Callback executor
+      exec_callbacks = lambda do |callbacks|
+        callbacks.each do |block|
+          instances.each { |instance| instance.instance_eval(&block) }
         end
-        
-        extend Table
-        extend Record::ClassMethods
-        include Record::InstanceMethods
+      end
+      # Execute
+      transaction do
+        exec_callbacks.call before
+        connection.execute(<<-SQL)
+          INSERT INTO #{to_class.table_name} (#{insert.join(', ')})
+          SELECT #{select.join(', ')}
+          FROM #{from_class.table_name}
+          #{where}
+        SQL
+        connection.execute("DELETE FROM #{from_class.table_name} #{where}")
+        exec_callbacks.call after
       end
     end
-  end
-  
-  module Migration
-    def self.included(base)
-      unless base.included_modules.include?(Included)
-        base.extend Migrator
-        base.send :include, Included
-        base.class_eval do
-          class <<self
-            alias_method :method_missing_without_mover, :method_missing
-            alias_method :method_missing, :method_missing_with_mover
-          end
-        end
+    
+    def reserve_id
+      id = nil
+      transaction do
+        id = connection.insert("INSERT INTO #{self.table_name} () VALUES ()")
+        connection.execute("DELETE FROM #{self.table_name} WHERE id = #{id}") if id
       end
+      id
     end
   end
   
-  module Included
+  module InstanceMethods
+    def move_to(to_class)
+      self.class.move_to(to_class, "#{self.class.primary_key} = #{id}", self)
+    end
   end
 end
 
-ActiveRecord::Base.send(:include, Mover::Base)
-ActiveRecord::Migration.send(:include, Mover::Migration)
+ActiveRecord::Base.send(:include, Mover)

data/require.rb

@@ -17,17 +17,11 @@ Require do
     name 'mover'
     homepage "http://github.com/winton/#{name}"
     summary "Move ActiveRecord records across tables like it ain't no thang"
-    version '0.1.1'
+    version '0.2.0'
   end
   
   bin { require 'lib/mover' }
-  
-  lib do
-    require 'digest/md5'
-    require 'lib/mover/migrator'
-    require 'lib/mover/record'
-    require 'lib/mover/table'
-  end
+  lib {}
   
   rakefile do
     gem(:active_wrapper)
@@ -44,6 +38,8 @@ Require do
     require 'rails/init'
     require 'pp'
     require 'spec/fixtures/article'
+    require 'spec/fixtures/article_archive'
     require 'spec/fixtures/comment'
+    require 'spec/fixtures/comment_archive'
   end
 end

data/spec/db/migrate/001_create_fixtures.rb

@@ -0,0 +1,28 @@
+class CreateFixtures < ActiveRecord::Migration
+  def self.up
+    [ :articles, :article_archives ].each do |table|
+      create_table table do |t|
+        t.string :title
+        t.string :body
+        t.boolean :read
+        t.datetime :moved_at
+      end
+    end
+    
+    [ :comments, :comment_archives ].each do |table|
+      create_table table do |t|
+        t.string :title
+        t.string :body
+        t.boolean :read
+        t.integer :article_id
+        t.datetime :moved_at
+      end
+    end
+  end
+
+  def self.down
+    [ :articles, :article_archives, :comments, :comment_archives ].each do |table|
+      drop_table table
+    end
+  end
+end

data/spec/fixtures/article.rb

@@ -1,4 +1,6 @@
 class Article < ActiveRecord::Base
   has_many :comments
-  is_movable :archive, :draft
+  before_move_to :ArticleArchive do
+    comments.each { |c| c.move_to(CommentArchive) }
+  end
 end

data/spec/fixtures/article_archive.rb

@@ -0,0 +1,6 @@
+class ArticleArchive < ActiveRecord::Base
+  has_many :comments, :class_name => 'CommentArchive', :foreign_key => 'article_id'
+  before_move_to :Article do
+    comments.each { |c| c.move_to(Comment) }
+  end
+end

data/spec/fixtures/comment.rb

@@ -1,4 +1,3 @@
 class Comment < ActiveRecord::Base
   belongs_to :article
-  is_movable :archive
 end

data/spec/fixtures/comment_archive.rb

@@ -0,0 +1,3 @@
+class CommentArchive < ActiveRecord::Base
+  belongs_to :article, :class_name => 'ArticleArchive', :foreign_key => 'article_id'
+end