undestroyable 0.0.1

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (C) 2012 Kot-Begemot
+
+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.md

@@ -0,0 +1,37 @@
+# Strategies
+
+* none
+    Deletes record, as with usual destroy method.
+* column
+    Updates deleted_at column of the record. This is default strategy,
+    if undestroyable is activated for model.
+* table
+    Move table into separate column
+* database
+    Move table into separate database
+
+# Options:
+
+* table_name
+    Same as model table.
+* table_suffix
+    Default prefix is: deleted
+* full_table_name
+    table_prefix + table_name + table_suffix.
+
+# Simple usage example:
+
+    class Bill < ActiveRecord::Base
+      undestroyable
+    end
+
+# Complicated usage example:
+
+    class ConceptCat < ActiveRecord::Base
+      undstroyable do
+        startegy :database
+        connection { adapter: "sqlite3", dbfile: ":memory:"}
+        table_name :scrap
+        table_suffix :metalic
+      end
+    end

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/cases/**/*_test.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/lib/undestroyable.rb

@@ -0,0 +1,21 @@
+module Undestroyable
+  autoload :Configuration, 'undestroyable/configuration'
+  autoload :STRATEGIES, 'undestroyable/strategies'
+  autoload :VERSION, 'undestroyable/version'
+
+  require 'undestroyable/orm'
+
+  module Orm
+    autoload :ActiveRecord, 'undestroyable/orm/active_record'
+  end
+
+  def self.config
+    @config ||= Configuration.new(copy_system: false).tap do |c|
+      def c.orm(orm_type)
+        constant = Undestroyable::Orm
+        loadable = Orm.get_by_key(orm_type)
+        constant.const_defined?(loadable) ? constant.const_get(loadable) : constant.const_missing(loadable)
+      end
+    end
+  end
+end

data/lib/undestroyable/configuration.rb

@@ -0,0 +1,142 @@
+module Undestroyable
+  
+  class WrongStrategyError < Exception; end
+  class ConnectionIsCompulsaryError < Exception; end
+
+  # Specifies which strategy to use for this configuration.
+  #
+  # Possible options include:
+  #   [:startegy]
+  #     [:none]
+  #       Deletes record, as with usual destroy method. This option may be used as a cancelation
+  #       of undestoyable state of record, for STI model as an example.
+  #     [:column]
+  #       Updates <tt>:deleted_at</tt> column of the record. This is default strategy,
+  #       in cafe if undestroyable is specified for model.
+  #     [:table]
+  #       Move record into separate table.
+  #     [:database]
+  #       Move table into separate database.
+  #     [:dump]
+  #       Marshal dump all deleted records into common table table.
+  #   [:table_name]
+  #     Keep alternative to table name. By default it will equivalent to one used by Model backend.
+  #     It is ignored by <tt>:none</tt> and <tt>::column</tt> strategies.
+  #   [:table_prefix]
+  #     Keep table prefix. If it is set not nil, it will be ignored for table creation. Default is nil.
+  #     It is ignored by <tt>:none</tt> and <tt>::column</tt> strategies.
+  #   [:table_suffix]
+  #     Keep table suffix. If it is set not nil, it will be ignored for table creation. Default is nil.
+  #     It is ignored by <tt>:none</tt> and <tt>::column</tt> strategies.
+  #   [:full_table_name]
+  #     Keep full table name. If this field is not specified it will be generated from 
+  #     table_name + table_prefix + table_suffix.
+  #     It is ignored by <tt>:none</tt> and <tt>::column</tt> strategies.
+  #   [:connection]
+  #     Keep credetial information for remote database connection.
+  #     *NB!* Compulsary for :database strategy, ignored for rest strategies.
+  #
+  # == EXAMPLES
+  #
+  #   class ConceptCat < ActiveRecord::Base
+  #     undstroyable do
+  #       startegy :table
+  #       table_name :metalic
+  #       table_suffix :scrap
+  #     end
+  #   end
+  #
+  #   class ConceptCat < ActiveRecord::Base
+  #     undstroyable do
+  #       startegy :database
+  #       connection {}
+  #       table_name :scrap
+  #     end
+  #   end
+  #
+  #  class ConceptCat < ActiveRecord::Base
+  #    undstroyable do
+  #      startegy :dump
+  #      table_name :scrap
+  #    end
+  #  end
+  #
+  class Configuration
+    
+    attr_reader :configuration
+
+    def initialize(opts = {},&block)
+      copy_system = opts[:copy_system].nil? ? true : opts.delete(:copy_system)
+      @configuration ||= (copy_system ? Undestroyable.config.configuration.dup : {})
+      @configuration[:strategy] ||= :column
+      prepare &block if block_given?
+    end
+
+    def prepare &block
+      instance_eval &block
+      raise(::Undestroyable::ConnectionIsCompulsaryError.new "Connection information is compulsary") if database? && connection_settings.blank?
+    end
+    alias_method :setup, :prepare
+
+    #[:strategy, :table_name, :table_suffix, :full_table_name, :connection]
+
+    ::Undestroyable::STRATEGIES.each do |strategy|
+      define_method "#{strategy}?" do
+        configuration[:strategy] == strategy
+      end
+    end
+
+    # Allows to access <tt>configuration</tt> values via provided keys.
+    # Example:
+    #
+    #   c = Undestroyable.config
+    #   c[:strategy] # => :column
+    def [](option_name)
+      # :full_table_name will be generated on first request
+      generate_full_name if option_name == :full_table_name && !configuration[:full_table_name]
+      configuration[option_name]
+    end
+
+    def strategy(shrtkey)
+      raise WrongStrategyError.new(%Q{Such strategy "#{shrtkey}" does not exists.}) unless ::Undestroyable::STRATEGIES.include? shrtkey.to_sym
+      table_name('dump') if shrtkey.to_sym == :dump && !@configuration[:table_name]
+      @configuration[:strategy] = shrtkey.to_sym
+    end
+
+    def table_name(alternative_table_name)
+      @configuration[:table_name] = alternative_table_name
+    end
+
+    def table_prefix(alternative_table_prefix)
+      @configuration[:table_prefix] = alternative_table_prefix
+    end
+
+    def table_suffix(alternative_table_suffix)
+      @configuration[:table_suffix] = alternative_table_suffix
+    end
+
+    def full_table_name(alternative_full_table_name)
+      @configuration[:full_table_name] = alternative_full_table_name
+    end
+
+    def connection(alternative_connection)
+      @configuration[:connection] = alternative_connection
+    end
+
+    def connection_settings
+      @configuration[:connection]
+    end
+
+    private
+
+    def generate_full_name
+      if @configuration[:table_prefix] || @configuration[:table_name] || @configuration[:table_suffix]
+        table_name = "#{@configuration[:table_prefix].to_s}_" if @configuration[:table_prefix]
+        (table_name ||= '') << @configuration[:table_name].to_s
+        table_name << "_#{@configuration[:table_suffix].to_s}" if @configuration[:table_suffix]
+        @configuration[:full_table_name] = table_name.to_sym
+      end
+    end
+
+  end
+end

data/lib/undestroyable/orm.rb

@@ -0,0 +1,16 @@
+module Undestroyable
+  module Orm
+    SUPPORTED = %(ActiveRecord).freeze
+
+    class UnexisingOrmError < RuntimeError; end
+
+    def Orm.get_by_key(key)
+      case key.to_sym
+      when :active_record
+        'ActiveRecord'
+      else
+        raise UnexisingOrmError.new "No orm matching: :#{key.to_s}"
+      end
+    end
+  end
+end

data/lib/undestroyable/orm/active_record.rb

@@ -0,0 +1,46 @@
+require 'active_record'
+
+module Undestroyable
+  module Orm
+    module ActiveRecord
+      autoload :Column,   'undestroyable/orm/active_record/column'
+      autoload :Table,    'undestroyable/orm/active_record/table'
+      autoload :Database, 'undestroyable/orm/active_record/database'
+      autoload :Dump,     'undestroyable/orm/active_record/dump'
+
+      def self.included(base)
+        base.instance_eval { alias_method :destroy!, :destroy }
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def undestroyable &block
+          undestr_config(&block) unless @undestr_config
+          undestr_config.table_name(table_name) unless undestr_config[:table_name]
+          undestr_include_startegy
+          undestr_config
+        end
+
+        protected
+
+        def undestr_include_startegy
+          undestr_strategy = undestr_config[:strategy]
+          if Undestroyable::STRATEGIES.include? undestr_strategy
+            if undestr_config.none?
+              #nothing should happen for this strategy.
+            else
+              include "Undestroyable::Orm::ActiveRecord::#{undestr_strategy.to_s.classify}".constantize
+            end
+          end
+        end
+
+        # Keeps undestroyable configuration for class.
+        def undestr_config &block
+          @undestr_config ||= Undestroyable::Configuration.new(&block)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, Undestroyable::Orm::ActiveRecord

data/lib/undestroyable/orm/active_record/column.rb

@@ -0,0 +1,29 @@
+module Undestroyable
+  module Orm
+    module ActiveRecord
+      # <tt>:column</tt> strategy is the easiest among the rest. It just updates <tt>:deleted_at</tt> column
+      # of the record, and set default scope conditions, to prevent its returning by default. Despite the record
+      # is actually just updated, no update callback will be triggered.
+      #
+      # == Example
+      #
+      #   class ConceptCat < ActiveRecord::Base
+      #     undstroyable do
+      #       startegy :column
+      #     end
+      #   end
+      #
+      module Column
+        def self.included(base)
+          base.send :default_scope, base.where('deleted_at IS NULL')
+        end
+
+        def destroy
+          run_callbacks :destroy do
+            update_column :deleted_at, Time.now
+          end
+        end
+      end
+    end
+  end
+end

data/lib/undestroyable/orm/active_record/database.rb

@@ -0,0 +1,64 @@
+module Undestroyable
+  module Orm
+    module ActiveRecord
+      # <tt>:database</tt> strategy will save any deleted record within remote database. <tt>:connection</tt> option
+      # *is required*. By default, it will use same naming as a actual table. In order to change the table name,
+      # following options can be specified within configuration:
+      #
+      #   [:table_name]
+      #     Keep alternative to table name. By default it will equivalent to one used by Model backend.
+      #   [:table_prefix]
+      #     Keep table prefix. If it is set not nil, it will be ignored for table creation. Default is nil.
+      #   [:table_suffix]
+      #     Keep table suffix. If it is set not nil, it will be ignored for table creation. Default is nil.
+      #   [:full_table_name]
+      #     Keep full table name. If this field is not specified it will be generated from
+      #     table_name + table_prefix + table_suffix.
+      #
+      # == Example
+      #
+      #   class ConceptCat < ActiveRecord::Base
+      #     undstroyable do
+      #       startegy :database
+      #       connection { adapter: "sqlite3", dbfile: ":memory:"}
+      #       table_name :scrap
+      #       table_suffix :metalic
+      #     end
+      #   end
+      #
+      module Database
+
+        def self.included(base)
+          base.send :include, Table
+          base.send :include, InstanceMethods
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          # Because undest_arel_table is just being ignored over there....
+          def undest_mirror
+            @undest_mirror ||= begin
+              copy = self.dup
+              copy.table_name = undestr_config[:full_table_name]
+              def copy.name; undestr_config[:full_table_name].to_s.classify; end
+              copy.establish_connection undestr_config[:connection]
+              copy
+            end
+          end
+          protected :undest_mirror
+        end
+
+        module InstanceMethods
+          def destroy
+            run_callbacks :destroy do
+              deleted_attributes = undest_compile_insert_attributes
+              deleted_attributes << [self.class.undest_arel_table['deleted_at'], Time.now.utc] if self.class.send(:undest_mirror).columns_hash['deleted_at']
+              self.class.undest_relation.insert deleted_attributes
+              destroy!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/undestroyable/orm/active_record/dump.rb

@@ -0,0 +1,84 @@
+module Undestroyable
+  module Orm
+    module ActiveRecord
+      # <tt>:dump</tt> strategy is the most simple one. It requires only one table for whole project to save a data
+      # in it. What it does internally, is just marshal dump an object and save it into specific table. That table
+      # should have predefined format. That allows to keep an objects of different class within same table. In order
+      # to change the table name, following options can be specified within configuration:
+      #
+      #   [:table_name]
+      #     Keep alternative to table name. By default it will equivalent to one used by Model backend.
+      #   [:table_prefix]
+      #     Keep table prefix. If it is set not nil, it will be ignored for table creation. Default is nil.
+      #   [:table_suffix]
+      #     Keep table suffix. If it is set not nil, it will be ignored for table creation. Default is nil.
+      #   [:full_table_name]
+      #     Keep full table name. If this field is not specified it will be generated from
+      #     table_name + table_prefix + table_suffix.
+      #
+      # == Table structure
+      #
+      # [:dump]
+      #   This is a text column that keepes deleted object.
+      # [:deleted_at]
+      #   This column keeps a time of the recodr deletion. Time is saved as UTC.
+      #
+      # == Example
+      #
+      #    Undestroyable.config do
+      #      strategy :dump
+      #      full_table_name :dump
+      #    end
+      #
+      #    class Order < ActiveRecord::Base
+      #      undestroyable
+      #    end
+      #
+      #    *or*
+      #
+      #    class Invoice < ActiveRecord::Base
+      #      undestroyable do
+      #        strategy :dump
+      #        table_suffix :dump
+      #      end
+      #    end
+      #
+      # +dump+ table will contain an order as an object.
+      #
+      # *NB!* Check out Marshal class in Ruby, for how to make this text back to object.
+      module Dump
+
+        def self.included(base)
+          base.send :include, InstanceMethods
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          # Because undest_arel_table is just being ignored over there....
+          def undest_mirror
+            @undest_mirror ||= begin
+              dump_table = ::Undestroyable::Orm::ActiveRecord::DumpTable
+              dump_table.table_name = undestr_config[:full_table_name]
+              dump_table.establish_connection(undestr_config[:connection]) unless undestr_config[:connection].blank?
+              dump_table
+            end
+          end
+          protected :undest_mirror
+        end
+
+        module InstanceMethods
+          def destroy
+            run_callbacks :destroy do
+              dump_attributes = {dump: Marshal::dump(self)}
+              dump_attributes.merge!(deleted_at: Time.now.utc) if self.class.send(:undest_mirror).columns_hash['deleted_at']
+              self.class.send(:undest_mirror).create(dump_attributes)
+              destroy!
+            end
+          end
+        end
+      end
+
+      class DumpTable < ::ActiveRecord::Base; end
+    end
+  end
+end

data/lib/undestroyable/orm/active_record/table.rb

@@ -0,0 +1,76 @@
+module Undestroyable
+  module Orm
+    module ActiveRecord
+      # <tt>:table</tt> strategy will save any deleted record within separate table. By default, it will use
+      # same naming as a actual table. In order to change the table name, following options can be specified
+      # within configuration:
+      #
+      #   [:table_name]
+      #     Keep alternative to table name. By default it will equivalent to one used by Model backend.
+      #   [:table_prefix]
+      #     Keep table prefix. If it is set not nil, it will be ignored for table creation. Default is nil.
+      #   [:table_suffix]
+      #     Keep table suffix. If it is set not nil, it will be ignored for table creation. Default is nil.
+      #   [:full_table_name]
+      #     Keep full table name. If this field is not specified it will be generated from
+      #     table_name + table_prefix + table_suffix.
+      #
+      # == Example
+      #
+      #   class ConceptCat < ActiveRecord::Base
+      #     undstroyable do
+      #       startegy :database
+      #       connection { adapter: "sqlite3", dbfile: ":memory:"}
+      #       table_name :scrap
+      #       table_suffix :metalic
+      #     end
+      #   end
+      #
+      module Table
+        def self.included(base)
+          base.send :include, InstanceMethods
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          def undest_arel_table
+            @undest_table ||= ::Arel::Table.new(undestr_config[:full_table_name], self)
+          end
+
+          def undest_relation
+            @undest_relation ||= ::ActiveRecord::Relation.new(undest_mirror, undest_arel_table)
+          end
+
+          # Because undest_arel_table is just being ignored over there.... 
+          def undest_mirror
+            @undest_mirror ||= begin
+              copy = self.dup
+              copy.table_name = undestr_config[:full_table_name]
+              copy
+            end
+          end
+          protected :undest_mirror
+        end
+
+        module InstanceMethods
+          def destroy
+            run_callbacks :destroy do
+              deleted_attributes = undest_compile_insert_attributes
+              deleted_attributes << [self.class.undest_arel_table['deleted_at'], Time.now.utc]
+              self.class.undest_relation.insert deleted_attributes
+              destroy!
+            end
+          end
+
+          def undest_compile_insert_attributes
+            attributes.map do |key, value|
+              [self.class.undest_arel_table[key], value]
+            end
+          end
+
+          protected :undest_compile_insert_attributes
+        end
+      end
+    end
+  end
+end

data/lib/undestroyable/strategies.rb

@@ -0,0 +1,3 @@
+module Undestroyable
+  STRATEGIES = [:none,:column,:table,:database,:dump].freeze
+end

data/lib/undestroyable/version.rb

@@ -0,0 +1,3 @@
+module Undestroyable
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: undestroyable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- E-Max
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-02 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &78020570 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *78020570
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &78020340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *78020340
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &78020140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *78020140
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: &78019870 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.2
+  type: :development
+  prerelease: false
+  version_requirements: *78019870
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: &78019660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *78019660
+description: An aim or this gem is to provide an agile and comfortable way for Ruby
+  developers to get rid of unnecessary data within their project databases.
+email:
+- emax@studentify.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/undestroyable/version.rb
+- lib/undestroyable/orm/active_record.rb
+- lib/undestroyable/orm/active_record/dump.rb
+- lib/undestroyable/orm/active_record/database.rb
+- lib/undestroyable/orm/active_record/column.rb
+- lib/undestroyable/orm/active_record/table.rb
+- lib/undestroyable/orm.rb
+- lib/undestroyable/strategies.rb
+- lib/undestroyable/configuration.rb
+- lib/undestroyable.rb
+- LICENSE
+- README.md
+- Rakefile
+homepage: http://github.com/kot-begemot/undestroyable
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: undestroyable
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Undestroyable gem
+test_files: []