undestroy 0.0.2 → 0.1.0

data/lib/undestroy/config.rb

@@ -1,23 +1,34 @@
 class Undestroy::Config
   OPTIONS = [
-    :table_name, :abstract_class, :fields, :migrate,
-    :source_class, :target_class, :internals
+    :table_name, :abstract_class, :fields, :migrate, :indexes, :prefix,
+    :source_class, :target_class, :internals, :model_paths
   ]
   attr_accessor *OPTIONS
 
   def initialize(options={})
+    self.indexes = false
     self.migrate = true
-    self.fields = {
-      :deleted_at => proc { Time.now }
-    }
+    self.prefix = "archive_"
+    self.fields = {}
+    self.model_paths = []
     self.internals = {
       :archive => Undestroy::Archive,
       :transfer => Undestroy::Transfer,
+      :restore => Undestroy::Restore
     }
 
+    add_field :deleted_at, :datetime do |instance|
+      Time.now
+    end
+
+    # Default for Rails apps
+    self.model_paths << Rails.root.join('app', 'models') if defined?(Rails)
+
     options.each do |key, value|
-      self[key] = value
+      self[key] = value.duplicable? ? value.dup : value
     end
+
+    self.class.catalog << self
   end
 
   def [](key)
@@ -37,11 +48,15 @@ class Undestroy::Config
   end
 
   def primitive_fields(object)
-    self.fields.inject({}) do |hash, (key, val)|
-      hash.merge(key => val.is_a?(Proc) ? val.call(object) : val)
+    self.fields.inject({}) do |hash, (key, field)|
+      hash.merge(key => field.value(object))
     end
   end
 
+  def add_field(name, *args, &block)
+    self.fields[name.to_sym] = Field.new(name, *args, &block)
+  end
+
   def self.configure
     yield(config) if block_given?
   end
@@ -50,5 +65,14 @@ class Undestroy::Config
     @config ||= self.new
   end
 
+  def self.catalog
+    @@catalog ||= []
+  end
+
+  def self.reset_catalog
+    @@catalog = []
+  end
+
 end
 
+require 'undestroy/config/field'

data/lib/undestroy/config/field.rb

@@ -0,0 +1,20 @@
+class Undestroy::Config::Field
+
+  attr_accessor :name, :type, :raw_value
+
+  def <=>(b)
+    name.to_s <=> b.name.to_s
+  end
+
+  def initialize(name, type, value=nil, &block)
+    self.name = name
+    self.type = type
+    self.raw_value = block || value || raise(ArgumentError, "Must pass a value or block")
+  end
+
+  def value(*args)
+    raw_value.is_a?(Proc) ? raw_value.call(*args) : raw_value
+  end
+
+end
+

data/lib/undestroy/restore.rb

@@ -0,0 +1,44 @@
+
+class Undestroy::Restore
+
+  attr_accessor :target, :config, :transfer
+
+  def initialize(args={})
+    validate_arguments(args)
+
+    self.target = args[:target]
+    self.config = args[:config]
+    self.transfer = args[:transfer]
+  end
+
+  def transfer
+    @transfer ||= config.internals[:transfer].new(
+      :klass => config.source_class,
+      :fields => transfer_fields
+    )
+  end
+
+  def run
+    transfer.run
+  end
+
+  protected
+
+  def validate_arguments(args)
+    unless (args.keys & [:target, :config]).size == 2
+      raise ArgumentError, ":target and :config are required keys"
+    end
+  end
+
+  def transfer_fields
+    self.target.attributes.inject({}) do |hash, (key, value)|
+      if config.fields.keys.include?(key.to_sym)
+        hash
+      else
+        hash.merge(key => value)
+      end
+    end
+  end
+
+end
+

data/lib/undestroy/version.rb

@@ -1,4 +1,4 @@
 module Undestroy
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end
 

data/lib/undestroy/without_binding.rb

@@ -2,6 +2,7 @@ require "undestroy/version"
 require "undestroy/config"
 require "undestroy/transfer"
 require "undestroy/archive"
+require "undestroy/restore"
 require "undestroy/binding"
 
 module Undestroy

data/test/fixtures/ar.rb

@@ -7,21 +7,25 @@ class Undestroy::Test::Fixtures::ARFixture
 
   def initialize(attributes={})
     @saved = false
-    self.attributes = attributes.dup
+    self.attributes = HashWithIndifferentAccess.new(attributes)
     self.attributes.delete(:id)
   end
 
   def [](key)
-    self.attributes[key.to_sym]
+    @attributes[key]
   end
 
   def []=(key, val)
-    self.attributes[key.to_sym] = val
+    @attributes[key] = val
   end
 
   # Method missing won't catch this one
   def id
-    self.attributes[:id]
+    self[:id]
+  end
+
+  def attributes
+    @attributes.stringify_keys
   end
 
   def save

data/test/fixtures/load_test/models1/test_model001.rb

@@ -0,0 +1,2 @@
+class TestModel001
+end

data/test/fixtures/load_test/models1/test_model002.rb

@@ -0,0 +1,2 @@
+class TestModel002
+end

data/test/fixtures/load_test/models1/test_module001.rb

@@ -0,0 +1,2 @@
+module TestModule001
+end

data/test/fixtures/load_test/models1/test_module001/test_model003.rb

@@ -0,0 +1,2 @@
+class TestModule001::TestModel003
+end

data/test/fixtures/load_test/models2/test_model001.rb

@@ -0,0 +1,2 @@
+class TestModel001
+end

data/test/fixtures/load_test/models2/test_model002.rb

@@ -0,0 +1,2 @@
+class TestModel002
+end

data/test/fixtures/load_test/models2/test_module001.rb

@@ -0,0 +1,2 @@
+module TestModule001
+end

data/test/fixtures/load_test/models2/test_module001/test_model003.rb

@@ -0,0 +1,2 @@
+class TestModule001::TestModel003
+end

data/test/helper.rb

@@ -15,6 +15,10 @@ module Undestroy::Test
 
   class Base < Assert::Context
 
+    teardown do
+      Undestroy::Config.reset_catalog
+    end
+
     teardown_once do
       `rm -f tmp/*.db`
     end
@@ -31,6 +35,10 @@ module Undestroy::Test
     establish_connection 'alt'
   end
 
+  module Helpers
+    autoload :ModelLoading, 'test/helpers/model_loading'
+  end
+
   module Integration
   end
 
@@ -39,5 +47,9 @@ module Undestroy::Test
     autoload :ARFixture, 'test/fixtures/ar'
     autoload :Archive, 'test/fixtures/archive'
   end
+
+  def self.fixtures_path(*paths)
+    File.join(File.expand_path(File.join(File.dirname(__FILE__), 'fixtures')), *paths)
+  end
 end
 

data/test/helpers/model_loading.rb

@@ -0,0 +1,20 @@
+module Undestroy::Test::Helpers::ModelLoading
+
+  def assert_loads_models(path, &block)
+    require 'active_support/dependencies'
+    ActiveSupport::Dependencies.hook!
+    ActiveSupport::Dependencies.autoload_paths += [path]
+
+    block.call
+
+    assert defined?(TestModel001), "TestModel001 did not load"
+    assert defined?(TestModel002), "TestModel002 did not load"
+    assert defined?(TestModule001), "TestModule001 did not load"
+    assert defined?(TestModule001::TestModel003), "Testmodule001::TestModel003 did not load"
+  ensure
+    ActiveSupport::Dependencies.autoload_paths -= [path]
+    ActiveSupport::Dependencies.remove_unloadable_constants!
+    ActiveSupport::Dependencies.unhook!
+  end
+
+end

data/test/integration/active_record_test.rb

@@ -16,7 +16,12 @@ module Undestroy::Test::Integration::ActiveRecordTest
     desc 'extensions'
 
     should "add extensions to AR" do
-      assert_respond_to :undestroy_model_binding, ActiveRecord::Base
+      assert_respond_to :undestroy, ActiveRecord::Base
+    end
+
+    should "add alias method chain in method_missing on AR::Migration" do
+      assert_respond_to :method_missing_with_undestroy, ActiveRecord::Migration.new
+      assert ActiveRecord::Migration.new.method(:method_missing_without_undestroy)
     end
   end
 
@@ -79,6 +84,50 @@ module Undestroy::Test::Integration::ActiveRecordTest
       assert (Time.now - archive.deleted_at) < 1.second
       assert_equal 0, @model.all.size
     end
+
+    should "restore an archived record removing the archive" do
+      @model.undestroy
+      @model.create(:name => "Fart")
+      original = @model.first
+      original.destroy
+
+      assert_equal 0, @model.count
+      @model.restore(1)
+
+      assert_equal 0, @model.archived.count
+      assert_equal 1, @model.count
+      assert_equal 1, @model.first.id
+      assert_equal "Fart", @model.first.name
+    end
+
+    should "restore an archived record and leave the archive when restore_copy called" do
+      @model.undestroy
+      @model.create(:name => "Fart")
+      original = @model.first
+      original.destroy
+
+      assert_equal 0, @model.count
+      @model.archived.first.restore_copy
+
+      assert_equal 1, @model.archived.count
+      assert_equal 1, @model.count
+    end
+
+    should "restore a relation of items when restore_all called" do
+      @model.undestroy
+      @model.create(:name => "Bobby")
+      @model.create(:name => "Billy")
+      @model.create(:name => "Jan")
+
+      assert_equal 3, @model.count
+      @model.destroy_all
+      assert_equal 0, @model.count
+
+      @model.archived.where("name LIKE ?", "B%").restore_all
+
+      assert_equal 2, @model.count
+      assert_equal 1, @model.archived.count
+    end
   end
 
   class BasicModelWithDifferentBase < Base

data/test/irb.rb

@@ -0,0 +1,2 @@
+require 'assert/setup'
+

data/test/unit/archive_test.rb

@@ -75,7 +75,7 @@ module Undestroy::Archive::Test
 
     should "eval lambdas with source instance as argument" do
       val = nil
-      @archive.config.fields[:test] = proc { |arg| val = arg; "FOO" }
+      @archive.config.add_field(:test, :string) { |arg| val = arg; "FOO" }
       target = @archive.transfer.target
       assert_equal @archive.source, val
       assert_equal "FOO", target.attributes[:test]

data/test/unit/binding/active_record/migration_statement_test.rb

@@ -0,0 +1,306 @@
+require 'assert'
+
+module Undestroy::Binding::ActiveRecord::MigrationStatement::Test
+
+  class Base < Undestroy::Test::Base
+    desc 'Binding::ActiveRecord::MigrationStatement class'
+    subject { @subject_class }
+
+    setup do
+      @subject_class = Undestroy::Binding::ActiveRecord::MigrationStatement
+      @catalog = Undestroy::Config.catalog
+
+      @source_class = Class.new(Undestroy::Test::ARMain)
+    end
+
+    def config
+      @source_class.undestroy_model_binding.config
+    end
+
+  end
+
+  class BasicInstance < Base
+    desc 'basic instance'
+    subject { @subject_class.new :foo }
+
+    should have_accessor :method_name, :arguments, :block
+  end
+
+  class AddClassMethod < Base
+    desc 'add class method'
+
+    setup do
+      @klass = Class.new do
+        @@method_missing_calls = []
+
+        def method_missing(*args, &block)
+          @@method_missing_calls << [args, block]
+        end
+
+        def self.method_missing_calls
+          @@method_missing_calls
+        end
+      end
+    end
+
+    should "add method method_missing_with_undestroy" do
+      subject.add(@klass)
+      assert_respond_to :method_missing_with_undestroy, @klass.new
+    end
+
+    should "alias original method_missing as method_missing_without_undestroy" do
+      subject.add(@klass)
+      assert @klass.new.method(:method_missing_without_undestroy)
+    end
+
+    should "always call original method_missing" do
+      subject.add(@klass)
+      @klass.new.foo(:bar) { }
+      assert_equal 1, @klass.method_missing_calls.size
+      assert_equal [:foo, :bar], @klass.method_missing_calls[0].first
+      assert_instance_of Proc, @klass.method_missing_calls[0].last
+    end
+
+    should "always create an instance of MethodStatement and call run! if run?" do
+      @source_class.table_name = 'source'
+      @source_class.undestroy
+      subject.add(@klass)
+      @klass.new.add_column :source, :foo, :string
+      assert_equal 2, @klass.method_missing_calls.size
+      assert_equal [:add_column, 'archive_source', :foo, :string], @klass.method_missing_calls[1].first
+    end
+  end
+
+  class InitMethod < Base
+    desc 'init method'
+    include Undestroy::Test::Helpers::ModelLoading
+
+    should "set required arg1 to method_name attr" do
+      obj = subject.new :method
+      assert_equal :method, obj.method_name
+    end
+
+    should "set remaining args to arguments attr as Array" do
+      obj = subject.new :method, :arg1, 'arg2', 3, :four => :val1, :five => :val2
+      assert_equal [:arg1, 'arg2', 3, { :four => :val1, :five => :val2 }], obj.arguments
+    end
+
+    should "set optional block to block attr" do
+      block = proc { "FOOO" }
+      obj = subject.new :method, &block
+      assert_equal block, obj.block
+      assert_equal "FOOO", obj.block.call
+    end
+
+    should "call load_models on all Config.config.model_paths if not loaded yet" do
+      path = Undestroy::Test.fixtures_path('load_test', 'models2')
+      Undestroy::Config.config.model_paths = [path]
+      assert_loads_models(path) do
+        subject.new :method
+      end
+      Undestroy::Config.config.model_paths = []
+    end
+  end
+
+  class SourceTableNameMethod < Base
+    desc 'source_table_name method'
+
+    should "return arguments[0]" do
+      obj = subject.new :method, 'table_name', 1
+      assert_equal 'table_name', obj.source_table_name
+    end
+  end
+
+  class TargetTableNameMethod < Base
+    desc 'target_table_name method'
+
+    should 'return "archive_#{original_table_name}" when :table_name config not set' do
+      @source_class.table_name = 'poop'
+      @source_class.undestroy
+      assert_equal 'archive_poop', subject.new(:method, 'poop').target_table_name
+    end
+
+    should 'return :table_name config value when set' do
+      @source_class.table_name = 'poop'
+      @source_class.undestroy :table_name => 'old_poop_table'
+      assert_equal 'old_poop_table', subject.new(:method, 'poop').target_table_name
+    end
+  end
+
+  class ConfigMethod < Base
+    desc 'config method'
+
+    should "fetch config object for the given table name from Undestroy::Config.catalog" do
+      @source_class.table_name = 'foobar'
+      @source_class.undestroy
+      assert_equal config, subject.new(:method, 'foobar').config
+    end
+  end
+
+  class SchemaActionMethod < Base
+    desc 'schema_action? method'
+
+    should "return true if method_name is a schema modification method" do
+      [
+        :create_table, :drop_table, :rename_table,
+        :add_column, :rename_column, :change_column, :remove_column
+      ].each do |method|
+        obj = subject.new method
+        assert obj.schema_action?
+      end
+    end
+
+    should "return false otherwise" do
+      obj = subject.new :method
+      assert_not obj.schema_action?
+    end
+  end
+
+  class IndexActionMethod < Base
+    desc 'index_action? method'
+
+    should "return true if method_name is an index modification method" do
+      [
+        :add_index, :remove_index
+      ].each do |method|
+        obj = subject.new method
+        assert obj.index_action?
+      end
+    end
+
+    should "return false otherwise" do
+      obj = subject.new :method
+      assert_not obj.index_action?
+    end
+  end
+
+  class RunQueryMethod < Base
+    desc 'run? method'
+
+    should "always return false if arguments are empty" do
+      obj = subject.new :method
+      assert_not obj.run?
+    end
+
+    should "always return false if no configuration is present for this *source* table name" do
+      @source_class.table_name = 'bar'
+      @source_class.undestroy
+      obj = subject.new :method, 'foo'
+      assert_not obj.run?
+    end
+
+    should "return true if :migrate is configured and schema_action? is true" do
+      @source_class.table_name = 'bar'
+      @source_class.undestroy
+      obj = subject.new :add_column, :bar, :name, :string
+      assert obj.schema_action?
+      assert obj.run?
+    end
+
+    should "return false if :migrate is configured and schema_action? is false" do
+      @source_class.table_name = 'bar'
+      @source_class.undestroy
+      obj = subject.new :method, :bar, :name, :string
+      assert_not obj.run?
+    end
+
+    should "return false if :migrate not configured for this table" do
+      @source_class.table_name = 'bar'
+      @source_class.undestroy :migrate => false
+      obj = subject.new :add_column, :bar, :name, :string
+      assert obj.schema_action?
+      assert_not obj.run?
+    end
+
+    should "return true if :index is configured and index_action? is true" do
+      @source_class.table_name = 'bar'
+      @source_class.undestroy :indexes => true
+      obj = subject.new :add_index, :bar
+      assert obj.index_action?
+      assert obj.run?
+    end
+
+    should "return false if :index is configured and index_action? is false" do
+      @source_class.table_name = 'bar'
+      @source_class.undestroy :indexes => true
+      obj = subject.new :method, :bar
+      assert_not obj.index_action?
+      assert_not obj.run?
+    end
+
+    should "return false if :index is not configured for this table" do
+      @source_class.table_name = 'bar'
+      @source_class.undestroy
+      obj = subject.new :add_index, :bar
+      assert obj.index_action?
+      assert_not obj.run?
+    end
+
+    # We will not rename a table that has been configured to a specific name
+    should "return false if :method_name is rename_table and :table_name configuration is set explicitly" do
+      @source_class.table_name = 'bar'
+      @source_class.undestroy :table_name => 'old_bar'
+      obj = subject.new :rename_table, :bar, :baz
+      assert_not obj.run?
+    end
+  end
+
+  class TargetArgsMethod < Base
+    desc 'target_arguments method'
+
+    setup do
+      @source_class.table_name = 'source'
+      @source_class.undestroy
+    end
+
+    should "leave original arguments alone" do
+      obj = subject.new :add_column, :source, :foo, :string
+      args = obj.arguments.dup
+      obj.target_arguments
+      assert_equal args, obj.arguments
+    end
+
+    should "substitute source table_name for target table_name" do
+      obj = subject.new :add_column, :source, :foo, :string
+      assert_equal ['archive_source', :foo, :string], obj.target_arguments
+    end
+
+    should "substitute arg[1] for target table_name on rename_table method" do
+      obj = subject.new :rename_table, :source, :new_source
+      assert_equal ['archive_source', 'archive_new_source'], obj.target_arguments
+    end
+  end
+
+  class RunBangMethod < Base
+    desc 'run! method'
+
+    setup do
+      @source_class.table_name = 'source'
+      @source_class.undestroy
+    end
+
+    should "accept callable argument to run on and call with (method_name, target_args, block)" do
+      called = false
+      callable = proc { |*args, &block| called = [args, block] }
+      block = proc { }
+      obj = subject.new :add_column, :source, :foo, :string, &block
+      obj.run!(callable)
+      assert_equal [obj.method_name, obj.target_arguments, block].flatten, called.flatten
+    end
+
+    should "run additional add_column calls for all config.fields on :create_table method" do
+      config.add_field :deleted_by_id, :integer, 1
+      calls = []
+      callable = proc { |*args, &block| calls << [args, block] }
+      obj = subject.new :create_table, :source
+      obj.run!(callable)
+      assert_equal 3, calls.size
+      assert_equal [:create_table, 'archive_source', nil], calls[0].flatten
+      assert_equal [:add_column, 'archive_source', :deleted_at, :datetime, nil], calls[1].flatten
+      assert_equal [:add_column, 'archive_source', :deleted_by_id, :integer, nil], calls[2].flatten
+    end
+
+  end
+
+end
+