undestroy 0.0.1 → 0.0.2

data/ARCH.md

@@ -0,0 +1,84 @@
+# Undestroy Model Structure
+
+This is the basic class structure of this gem.  It was designed to be
+modular and easy to tailor to your specific needs.
+
+### `Config`
+
+Holds configuration information for Undestroy.  An instance is created
+globally and serves as defaults for each model using Undestroy.  Each
+model also creates its own instance of Config allowing any model to
+override any of the globally configurable options.
+
+To change global defaults use this configuration DSL:
+
+```ruby
+Undestroy::Config.configure do |config|
+  config.abstract_class = ArchiveModel
+  config.fields = {
+    :deleted_at => proc { Time.now },
+    :deleted_by_id => proc { User.current.id if User.current }
+  }
+end
+```
+
+This changes the default abstract class from ActiveRecord::Base to a
+model called ArchiveModel.  This also sets the default fields to include
+a deleted_by_id which automatically sets the current user as the deleter
+of the record.
+
+Possible configuration options are listed in the _Usage_ section above.
+
+### `Archive`
+
+Map the source model's schema to the archive model's and initiate the
+transfer through `Transfer`.  When `run` is called the Transfer is
+initialized with a primitive hash mapping the schema to the archive
+table.
+
+Initialized with:
+
+* `:config`: Instance of Undestroy::Config for this model
+* `:source`: Instance of the source model
+
+### `Restore`
+
+Map the archive model's schema to the source model's and initiate the
+transfer through `Transfer`
+
+Initialized with:
+
+* `:config`: Instance of Undestroy::Config for this model
+* `:archive`: Instance of the archived model
+
+### `Transfer`
+
+Handles the actual movement of data from one table to another.  This
+class simply uses the AR interface to create and delete the appropriate
+records.  This can be subclassed to provide enhanced performance or
+customized behavior for your situation.
+
+Initialized with:
+
+* `:fields`: Hash of field names to values to be stored in this table
+* `:klass`: Target AR model which will be created with these attributes
+
+### `Binding::ActiveRecord`
+
+Binds the base functionality to ActiveRecord.  It is initialized by the
+parameters to the `undestroy` class method and contains the method that
+is bound to the `before_destroy` callback that performs the archiving
+functions.  Any of the code that handles ActiveRecord specific logic
+lives in here.
+
+Initialized with: *Config options from above*
+
+Attributes:
+
+* `config`: Returns this model's config object
+* `model`: The AR model this instnace was created for
+
+Methods:
+
+* `before_destroy`: Perform the archive process
+

data/Gemfile

@@ -1,6 +1,7 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in undestroy.gemspec
 gemspec
 
 gem 'rake'
+gem 'sqlite3'
+

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Travis Petticrew
+Copyright (c) 2012 Travis Petticrew and Team Insight
 
 MIT License
 

data/README.md

@@ -3,9 +3,9 @@
 Allow copying records to alternate table before destroying an
 ActiveRecord model for archiving purposes.  Data will be mapped
 one-to-one to the archive table schema.  Additional fields can also be
-configured for additional tracking information.  Archive table schema
+configured for additional tracking information.  -Archive table schema
 will automatically be updated when the parent model's table is migrated
-through Rails.
+through Rails.- (not yet)
 
 ## Installation
 
@@ -21,21 +21,34 @@ Or install it yourself as:
 
     $ gem install undestroy
 
+You can also tell Undestroy to not extend ActiveRecord when required by
+using this line in your Gemfile instead:
+
+    gem 'undestroy', :require => 'undestroy/without_binding'
+
+If you do this you must call
+`Undestroy::Binding::ActiveRecord.add(MyARSubclass)` where
+`MYARSubclass` is the class you want Undestroy to extend instead.
+
 ## Usage
 
-To activate Undestroy on a model, simply call the `undestroyable` method
+To activate Undestroy on a model, simply call the `undestroy` method
 on the class like so:
 
-    class Person < ActiveRecord::Base
-      undestroyable
-    end
+```ruby
+class Person < ActiveRecord::Base
+  undestroy
+end
+```
 
-This method also can accept an options hash to further customize
+This method can also accept an options hash to further customize
 Undestroy to your needs.
 
-* `:table_name`:  use this table for archiving
-* `:class_name`:  use this AR model for archiving
-* `:connection`:  use this connection for archiving
+* `:table_name`:  use this table for archiving (Defaults to the
+  source class's table_name prefixed with "archive_").
+* `:abstract_class`:  use this as the base class for the target_class
+  specify an alternate for custom extensions / DB connections (defaults
+  to ActiveRecord::Base)
 * `:fields`:  Specify a hash of fields to values for additional fields
   you would like to include on the archive table -- lambdas will be
   called with the instance being destroyed and returned value will be
@@ -43,44 +56,41 @@ Undestroy to your needs.
 * `:migrate`:  Should Undestroy migrate the archive table together with
   this model's table (default: true)
 
-    $ person = Person.find(1)
-    $ person.destroy
-    # => Inserts person data into archive_people table
-    # => Deletes person data from people table
-
-## Stucture
-
-This is the basic class structure of this gem.  It was designed to be
-modular and easy to tailor to your specific needs.
-
-### `Archive`
-
-Map the source model's schema to the archive model's and initiate the
-transfer through `Transfer`.  When `run` is called the Transfer is
-initialized with a primitive hash mapping the schema to the archive
-table.
-
-Initialized with:
-
-* `:config`: Instance of Undestroy::Config for this model
-* `:source`: Instance of the source model
-
-### `Restore`
-
-Map the archive model's schema to the source model's and initiate the
-transfer through `Transfer`
-
-Initialized with:
-
-* `:config`: Instance of Undestroy::Config for this model
-* `:archive`: Instance of the archived model
-
-### `Transfer`
-
-Handles the actual movement of data from one table to another.  This
-class simply uses the AR interface to create and delete the appropriate
-records.  This can be subclassed to provide enhanced performance or
-customized behavior for your situation.
+Internal Options (for advanced users):
+
+* `:source_class`:  the AR model of the originating data.  Set
+  automatically to class `undestroy` method is called on.
+* `:target_class`:  use this AR model for archiving.  Set automatically
+  to dynamically generated class based on `archive_*` options.
+* `internals`: internal classes to use for archival process.  Possible
+  keys are `:archive`, `:transfer` and `:restore`.  Defaults to
+  corresponding internal classes.  Customize to your heart's content.
+
+```
+$ person = Person.find(1)
+$ person.destroy
+# => Inserts person data into archive_people table
+# => Deletes person data from people table
+```
+
+## Configuring
+
+You can specify custom global configurations for Undestroy through a
+configuration block in your application initializer:
+
+```ruby
+Undestroy::Config.configure do |config|
+  config.abstract_class = ArchiveModelBase
+  config.fields = {
+    :deleted_at => proc { Time.now },
+    :deleted_by_id => proc { User.current.id if User.current }
+  }
+end
+```
+
+Options set in this block will be the default for all models with
+undestroy activated.  They can be overriden with options passed to the
+`undestroy` method
 
 ## Contributing
 

data/lib/undestroy.rb

@@ -1,5 +1,4 @@
-require "undestroy/version"
+# Default behavior is to setup binding to ORM
+# If you want a non-intrusive require use 'undestroy/without_binding'
+require 'undestroy/with_binding'
 
-module Undestroy
-  # Your code goes here...
-end

data/lib/undestroy/archive.rb

@@ -0,0 +1,36 @@
+
+class Undestroy::Archive
+  attr_accessor :source, :config, :transfer
+
+  def initialize(args={})
+    validate_arguments(args)
+
+    self.source = args[:source]
+    self.config = args[:config]
+    self.transfer = args[:transfer]
+  end
+
+  def transfer
+    @transfer ||= self.config.internals[:transfer].new(
+      :klass => self.config.target_class,
+      :fields => archive_fields
+    )
+  end
+
+  def run
+    transfer.run
+  end
+
+  protected
+
+  def archive_fields
+    self.config.primitive_fields(self.source).merge(self.source.attributes)
+  end
+
+  def validate_arguments(args)
+    unless (args.keys & [:source, :config]).size == 2
+      raise ArgumentError, ":source and :config are required keys" 
+    end
+  end
+end
+

data/lib/undestroy/binding.rb

@@ -0,0 +1,8 @@
+module Undestroy::Binding
+  autoload :ActiveRecord, 'undestroy/binding/active_record'
+
+  def self.bind
+    Undestroy::Binding::ActiveRecord.add(::ActiveRecord::Base)
+  end
+end
+

data/lib/undestroy/binding/active_record.rb

@@ -0,0 +1,63 @@
+require 'active_record'
+
+class Undestroy::Binding::ActiveRecord
+  attr_accessor :config, :model
+
+  def initialize(model, options={})
+    ensure_is_ar! model
+
+    self.model = model
+    self.config = Undestroy::Config.config.merge(options)
+
+    set_defaults
+  end
+
+  def before_destroy(instance)
+    config.internals[:archive].new(:config => config, :source => instance).run
+  end
+
+  protected
+
+  def set_defaults
+    self.config.source_class = self.model
+    self.config.table_name ||= table_prefix + self.model.table_name if self.model.respond_to?(:table_name)
+    self.config.target_class ||= create_target_class
+    ensure_is_ar! self.config.target_class
+  end
+
+  # Builds a dynamic AR class representing the archival table
+  def create_target_class
+    Class.new(self.config.abstract_class || ActiveRecord::Base).tap do |target_class|
+      target_class.table_name = self.config.table_name
+    end
+  end
+
+  def table_prefix
+    "archive_"
+  end
+
+  def ensure_is_ar!(klass)
+    raise ArgumentError, "#{klass.inspect} must be an ActiveRecord model" unless is_ar?(klass)
+  end
+
+  def is_ar?(klass)
+    klass.is_a?(Class) && klass.ancestors.include?(ActiveRecord::Base)
+  end
+
+  # Add binding to the given class if it doesn't already have it
+  def self.add(klass=ActiveRecord::Base)
+    klass.class_eval do
+      class_attribute :undestroy_model_binding, :instance_writer => false
+
+      def self.undestroy(options={})
+        before_destroy do
+          self.undestroy_model_binding.before_destroy(self) if undestroy_model_binding
+        end unless self.undestroy_model_binding
+        self.undestroy_model_binding = Undestroy::Binding::ActiveRecord.new(self, options)
+      end
+
+    end unless klass.respond_to?(:undestroy_model_binding)
+  end
+
+end
+

data/lib/undestroy/config.rb

@@ -0,0 +1,54 @@
+class Undestroy::Config
+  OPTIONS = [
+    :table_name, :abstract_class, :fields, :migrate,
+    :source_class, :target_class, :internals
+  ]
+  attr_accessor *OPTIONS
+
+  def initialize(options={})
+    self.migrate = true
+    self.fields = {
+      :deleted_at => proc { Time.now }
+    }
+    self.internals = {
+      :archive => Undestroy::Archive,
+      :transfer => Undestroy::Transfer,
+    }
+
+    options.each do |key, value|
+      self[key] = value
+    end
+  end
+
+  def [](key)
+    self.send(key) if OPTIONS.include?(key)
+  end
+
+  def []=(key, value)
+    self.send("#{key}=", value) if OPTIONS.include?(key)
+  end
+
+  def to_hash
+    OPTIONS.inject({}) { |hash, key| hash.merge(key => self[key]) }
+  end
+
+  def merge(object)
+    self.class.new(self.to_hash.merge(object.to_hash))
+  end
+
+  def primitive_fields(object)
+    self.fields.inject({}) do |hash, (key, val)|
+      hash.merge(key => val.is_a?(Proc) ? val.call(object) : val)
+    end
+  end
+
+  def self.configure
+    yield(config) if block_given?
+  end
+
+  def self.config
+    @config ||= self.new
+  end
+
+end
+

data/lib/undestroy/transfer.rb

@@ -0,0 +1,22 @@
+
+class Undestroy::Transfer
+  attr_accessor :target
+
+  def initialize(args={})
+    raise ArgumentError, ":klass option required" unless args[:klass]
+    args[:fields] ||= {}
+
+    self.target = args[:klass].new
+
+    # Set instance values directly to avoid AR's filtering of protected fields
+    args[:fields].each do |field, value|
+      self.target[field] = value
+    end
+  end
+
+  def run
+    self.target.save
+  end
+
+end
+

data/lib/undestroy/version.rb

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

data/lib/undestroy/with_binding.rb

@@ -0,0 +1,5 @@
+require 'undestroy/without_binding'
+
+# Bind Undestroy to ORM
+Undestroy::Binding.bind
+