mover 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2009 Winton Welsh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 
+the Software, and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,95 @@
+Mover
+=====
+
+Move ActiveRecord records across tables like it ain't no thang.
+
+Requirements
+------------
+
+<pre>
+sudo gem install mover
+</pre>
+
+<a name="create_the_movable_table"></a>
+
+Create the movable table
+------------------------
+
+Migration:
+
+<pre>
+class CreateArchivedArticles < ActiveRecord::Migration
+  def self.up
+    Article.create_movable_table(
+      :archived,
+      :columns => %w(id title body created_at),
+      :indexes => %w(id created_at)
+    )
+    add_column :archived_articles, :move_id, :string
+    add_column :archived_articles, :moved_at, :datetime
+  end
+
+  def self.down
+    Article.drop_movable_table(:archived)
+  end
+end
+</pre>
+
+The first parameter names your movable table. In this example, the table is named <code>archived_articles</code>.
+
+Options:
+
+* <code>:columns</code> - Only use certain columns from the original table. Defaults to all.
+* <code>:indexes</code> - Only create certain indexes. Defaults to all.
+
+We also added two columns, <code>move\_id</code> and <code>moved\_at</code>. These are <a href="#magic_columns">magic columns</a>.
+
+<a name="define_the_model"></a>
+
+Define the model
+----------------
+
+<pre>
+class Article < ActiveRecord::Base
+  is_movable :archived
+end
+</pre>
+
+The <code>is_movable</code> method takes any number of parameters for multiple movable tables.
+
+Moving records
+--------------
+
+<pre>
+Article.last.move_to(:archived)
+Article.move_to(:archived, [ "created_at > ?", Date.today ])
+</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>).
+
+Restoring records
+-----------------
+
+<pre>
+Article.move_from(:archived, [ "created_at > ?", Date.today ])
+ArchivedArticle.last.move_from
+</pre>
+
+You can access the movable table by prepending its name to the original class name. In this example, you would use <code>ArchivedArticle</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.

data/Rakefile

@@ -0,0 +1,2 @@
+require "#{File.dirname(__FILE__)}/require"
+Require.rakefile!

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/rails/init"

data/lib/mover/migrator.rb

@@ -0,0 +1,43 @@
+module Mover
+  module Migrator
+    
+    def method_missing_with_mover(method, *arguments, &block)
+      args = Marshal.load(Marshal.dump(arguments))
+      method_missing_without_mover(method, *arguments, &block)
+      supported = [
+        :add_column, :add_timestamps, :change_column,
+        :change_column_default, :change_table,
+        :drop_table, :remove_column, :remove_columns,
+        :remove_timestamps, :rename_column, :rename_table
+      ]
+      
+      # Don't change these columns
+      %w(moved_at move_id).each do |column|
+        return if args.include?(column) || args.include?(column.intern)
+      end
+      
+      if !args.empty? && supported.include?(method)
+        connection = ActiveRecord::Base.connection
+        table_name = ActiveRecord::Migrator.proper_table_name(args[0])
+        # Find model
+        klass = Object.subclasses_of(ActiveRecord::Base).detect do |klass|
+          if klass.respond_to?(:movable_types)
+            klass.table_name.to_s == table_name
+          end
+        end
+        # Run migration on movable table
+        if klass
+          klass.movable_types.each do |type|
+            args[0] = [ type, table_name ].join('_')
+            if method == :rename_table
+              args[1] = [ type, args[1].to_s ].join('_')
+            end
+            if connection.table_exists?(args[0])
+              connection.send(method, *args, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mover/record.rb

@@ -0,0 +1,114 @@
+module Mover
+  module Base
+    module Record
+      module ClassMethods
+        
+        def move_from(type, conditions)
+          klass = movable_class(type)
+          if klass
+            if klass.column_names.include?('move_id')
+              klass.find_each(:conditions => conditions) do |record|
+                record.move_from
+              end
+            else
+              execute_move(klass, self, conditions)
+            end
+          end
+        end
+        
+        def move_to(type, conditions)
+          if movable_class(type).column_names.include?('move_id')
+            self.find_each(:conditions => conditions) do |record|
+              record.move_to(type)
+            end
+          else
+            execute_move(self, movable_class(type), conditions)
+          end
+        end
+        
+        private
+        
+        def execute_move(from_class, to_class, conditions, &block)
+          add_conditions! where = '', conditions
+          insert = from_class.column_names & to_class.column_names
+          insert.collect! { |col| connection.quote_column_name(col) }
+          select = insert.clone
+          yield(insert, select) if block_given?
+          if to_class.column_names.include?('moved_at')
+            insert << connection.quote_column_name('moved_at')
+            select << connection.quote(Time.now)
+          end
+          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}")
+        end
+        
+        def movable_class(type)
+          eval(type.to_s.classify + self.table_name.classify)
+        rescue
+          raise "#{self.table_name.classify} needs an `is_movable :#{type}` definition"
+        end
+      end
+    
+      module InstanceMethods
+        
+        def move_from
+          return unless self.respond_to?(:moved_from_class)
+          # Move associations
+          moved_from_class.reflect_on_all_associations.each do |association|
+            if move_association?(association)
+              klass = association.klass.send(:movable_class, self.class.movable_type)
+              klass.find_each(:conditions => [ 'move_id = ?', self.move_id ]) do |record|
+                record.move_from
+              end
+            end
+          end
+          # Move record
+          conditions = "#{self.class.primary_key} = #{id}"
+          moved_from_class.send(:execute_move, self.class, moved_from_class, conditions)
+        end
+        
+        def move_to(type)
+          return if self.respond_to?(:moved_from_class)
+          klass = self.class.send :movable_class, type
+          if klass
+            # Create movable_id
+            if !self.movable_id && klass.column_names.include?('move_id')
+              self.movable_id = Digest::MD5.hexdigest("#{self.class.name}#{self.id}")
+            end
+            # Move associations
+            self.class.reflect_on_all_associations.each do |association|
+              if move_association?(association)
+                self.send(association.name).each do |record|
+                  record.movable_id = self.movable_id
+                  record.move_to(type)
+                end
+              end
+            end
+            # Move record
+            me = self
+            conditions = "#{self.class.primary_key} = #{id}"
+            self.class.send(:execute_move, self.class, klass, conditions) do |insert, select|
+              if me.movable_id
+                insert << connection.quote_column_name('move_id')
+                select << connection.quote(self.movable_id)
+              end
+            end
+            self.movable_id = nil
+          end
+        end
+        
+        private
+        
+        def move_association?(association)
+          association.klass.respond_to?(:movable_types) &&
+          association.macro.to_s =~ /^has/
+        end
+      end
+    end
+  end
+end

data/lib/mover/table.rb

@@ -0,0 +1,82 @@
+module Mover
+  module Base
+    module Table
+      
+      def create_movable_table(type, options={})
+        movable_table = [ type, table_name ].join('_')
+        columns =
+          if options[:columns]
+            options[:columns].collect { |c| "`#{c}`" }.join(', ')
+          else
+            '*'
+          end
+        engine = options[:engine]
+        engine ||=
+          if connection.class.to_s.include?('Mysql')
+            "ENGINE=InnoDB"
+          end
+        if table_exists? and !connection.table_exists?(movable_table)
+          # Create table
+          connection.execute(<<-SQL)
+            CREATE TABLE #{movable_table} #{engine}
+            AS SELECT #{columns}
+            FROM #{table_name}
+            WHERE false;
+          SQL
+          # Create indexes
+          options[:indexes] ||= indexed_columns(table_name)
+          options[:indexes].each do |column|
+            connection.add_index(movable_table, column)
+          end
+        end
+      end
+    
+      def drop_movable_table(*types)
+        types.each do |type|
+          connection.execute("DROP TABLE IF EXISTS #{[ type, table_name ].join('_')}")
+        end
+      end
+      
+      private
+      
+      def indexed_columns(table_name)
+        # MySQL
+        if connection.class.to_s.include?('Mysql')
+          index_query = "SHOW INDEX FROM #{table_name}"
+          indexes = connection.select_all(index_query).collect do |r|
+            r["Column_name"]
+          end
+        # PostgreSQL
+        # http://stackoverflow.com/questions/2204058/show-which-columns-an-index-is-on-in-postgresql/2213199
+        elsif connection.class.to_s.include?('PostgreSQL')
+          index_query = <<-SQL
+            select
+              t.relname as table_name,
+              i.relname as index_name,
+              a.attname as column_name
+            from
+              pg_class t,
+              pg_class i,
+              pg_index ix,
+              pg_attribute a
+            where
+              t.oid = ix.indrelid
+              and i.oid = ix.indexrelid
+              and a.attrelid = t.oid
+              and a.attnum = ANY(ix.indkey)
+              and t.relkind = 'r'
+              and t.relname = '#{table_name}'
+            order by
+              t.relname,
+              i.relname
+          SQL
+          indexes = connection.select_all(index_query).collect do |r|
+            r["column_name"]
+          end
+        else
+          raise 'Mover does not support this database adapter'
+        end
+      end
+    end
+  end
+end

data/lib/mover.rb

@@ -0,0 +1,69 @@
+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
+    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
+        end
+        
+        types.each do |type|
+          eval <<-RUBY
+            class ::#{type.to_s.classify}#{self.table_name.classify} < ActiveRecord::Base
+              include Mover::Base::Record::InstanceMethods
+              
+              self.table_name = "#{type}_#{self.table_name}"
+              
+              def self.movable_type
+                #{type.inspect}
+              end
+              
+              def moved_from_class
+                #{self.table_name.classify}
+              end
+            end
+          RUBY
+        end
+        
+        extend Table
+        extend Record::ClassMethods
+        include Record::InstanceMethods
+      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
+      end
+    end
+  end
+  
+  module Included
+  end
+end
+
+ActiveRecord::Base.send(:include, Mover::Base)
+ActiveRecord::Migration.send(:include, Mover::Migration)

data/log/development.log

@@ -0,0 +1,6 @@
+  SQL (0.2ms)   SET SQL_AUTO_IS_NULL=0
+  User Load (59.6ms)   SELECT * FROM `users` ORDER BY users.id DESC LIMIT 1
+  User Columns (21.6ms)   SHOW FIELDS FROM `users`
+  SQL (0.3ms)   SET SQL_AUTO_IS_NULL=0
+  SQL (0.3ms)   SHOW TABLES
+  User Columns (13.0ms)   SHOW FIELDS FROM `users`

data/rails/init.rb

@@ -0,0 +1,2 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../require")
+Require.rails_init!

data/require.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+gem 'require'
+require 'require'
+
+Require do
+  gem(:active_wrapper, '=0.2.3') { require 'active_wrapper' }
+  gem :require, '=0.2.6'
+  gem(:rake, '=0.8.7') { require 'rake' }
+  gem :rspec, '=1.3.0'
+  
+  gemspec do
+    author 'Winton Welsh'
+    dependencies do
+      gem :require
+    end
+    email 'mail@wintoni.us'
+    name 'mover'
+    homepage "http://github.com/winton/#{name}"
+    summary "Move ActiveRecord records across tables like it ain't no thang"
+    version '0.1.0'
+  end
+  
+  bin { require 'lib/mover' }
+  
+  lib do
+    require 'digest/md5'
+    require 'lib/mover/migrator'
+    require 'lib/mover/record'
+    require 'lib/mover/table'
+  end
+  
+  rakefile do
+    gem(:active_wrapper)
+    gem(:rake) { require 'rake/gempackagetask' }
+    gem(:rspec) { require 'spec/rake/spectask' }
+    require 'require/tasks'
+  end
+  
+  rails_init { require 'lib/mover' }
+  
+  spec_helper do
+    gem(:active_wrapper)
+    require 'require/spec_helper'
+    require 'rails/init'
+    require 'pp'
+    require 'spec/fixtures/article'
+    require 'spec/fixtures/comment'
+  end
+end

data/spec/Rakefile

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'active_wrapper/tasks'
+  
+  ActiveWrapper::Tasks.new(
+    :base => File.dirname(__FILE__),
+    :env => ENV['ENV']
+  )
+rescue Exception
+end

data/spec/config/database.yml.example

@@ -0,0 +1,6 @@
+test:
+  adapter: mysql
+  database: mover
+  username: root
+  password: 
+  host: localhost

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

@@ -0,0 +1,34 @@
+class CreateArticles < ActiveRecord::Migration
+  def self.up
+    create_table :articles do |t|
+      t.string :title
+      t.string :body
+      t.boolean :read
+    end
+    add_index :articles, :title
+    
+    Article.create_movable_table(:archived)
+    add_column :archived_articles, :move_id, :string
+    add_column :archived_articles, :moved_at, :datetime
+    
+    Article.create_movable_table(:drafted)
+    
+    create_table :comments do |t|
+      t.string :title
+      t.string :body
+      t.boolean :read
+      t.integer :article_id
+    end
+    
+    Comment.create_movable_table(:archived)
+    add_column :archived_comments, :move_id, :string
+    add_column :archived_comments, :moved_at, :datetime
+  end
+
+  def self.down
+    drop_table :articles
+    drop_table :comments
+    Article.drop_movable_table(:archived)
+    Comment.drop_movable_table(:archived)
+  end
+end

data/spec/db/migrate/002_add_permalink.rb

@@ -0,0 +1,9 @@
+class AddPermalink < ActiveRecord::Migration
+  def self.up
+    add_column :articles, :permalink, :string
+  end
+
+  def self.down
+    remove_column :articles, :permalink
+  end
+end

data/spec/db/migrate/003_remove_magic_columns.rb

@@ -0,0 +1,9 @@
+class RemoveMagicColumns < ActiveRecord::Migration
+  def self.up
+    remove_column :articles, :move_id
+    remove_column :articles, :moved_at
+  end
+
+  def self.down
+  end
+end

data/spec/fixtures/article.rb

@@ -0,0 +1,4 @@
+class Article < ActiveRecord::Base
+  has_many :comments
+  is_movable :archived, :drafted
+end

data/spec/fixtures/comment.rb

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