Build ka scrub types

.gitignore

@@ -1 +1,2 @@
 Gemfile.lock
+.idea

README.md

@@ -16,33 +16,44 @@ gem 'acts_as_scrubbable'
 
 ## Usage
 
-Simple add the configuration for your fields that map directly to your columns
+Add the configuration for your fields that map directly to your columns and a scrub_type
+for those columns.
 
+Default Scrub types include:
+- `scrub` - scrub the field's value based on it's name or mapping (see mapping case below)
+- `skip` - do not scrub the field's value
+- `wipe` - set the field's value to nil on scrub
+- `sterilize` - delete all records for this model on scrub
 
 ```ruby
-class User < ActiveRecord::Base
+class ScrubExample < ActiveRecord::Base
   ...
 
-  acts_as_scrubbable :first_name, :last_name
+  acts_as_scrubbable :scrub, :first_name # first_name will be random after `scrub!`
+  acts_as_scrubbable :skip, :middle_name # middle_name will be original value after `scrub!`
+  acts_as_scrubbable :wipe, :last_name # last_name will be `nil` after `scrub!`
 
 
   # optionally you can add a scope to limit the rows to update
   scope :scrubbable_scope, -> { where(some_value: true) }
 
   ...
 end
-```
 
+class SterilizeExample < ActiveRecord::Base
+  acts_as_scrubbable :sterilize # table will contain no records after `scrub!`
+end
+
+```
 
 Incase the mapping is not straight forward
 
 ```ruby
 class Address
-  acts_as_scrubbable :lng => :longitude, :lat => :latitude
+  acts_as_scrubbable :scrub, :lng => :longitude, :lat => :latitude
 end
 ```
 
-
 ### To run
 
 The confirmation message will be the db host
@@ -75,22 +86,31 @@ If you want to limit the classes you to be scrubbed you can set the `SCRUB_CLASS
 rake scrub SCRUB_CLASSES=Blog,Post
 ```
 
-If you want to skip the afterhook
+If you want to skip the beforehook
 
 ```
-rake scrub SKIP_AFTERHOOK=true
+rake scrub SKIP_BEFOREHOOK=true
 ```
 
+If you want to skip the afterhook
 
+```
+rake scrub SKIP_AFTERHOOK=true
+```
 
 ### Extending
 
-You may find the need to extend or add additional generators or an after_hook
+You may find the need to extend or add additional generators or an before_hook/after_hook
 
 ```ruby
 ActsAsScrubbable.configure do |c|
   c.add :email_with_prefix, -> { "prefix-#{Faker::Internet.email}" }
 
+  c.before_hook do
+    puts "Running before scrub"
+    raise "Don't run in production" if Rails.env.production?
+  end
+
   c.after_hook do
     puts "Running after commit"
     ActiveRecord::Base.connection.execute("TRUNCATE some_table")

lib/acts_as_scrubbable.rb

@@ -11,11 +11,18 @@ module ActsAsScrubbable
   autoload :Scrub
   autoload :VERSION
 
-
   def self.configure(&block)
     yield self
   end
 
+  def self.before_hook(&block)
+    @before_hook = block
+  end
+
+  def self.execute_before_hook
+    @before_hook.call if @before_hook
+  end
+
   def self.after_hook(&block)
     @after_hook = block
   end
@@ -45,16 +52,18 @@ def self.scrub_map
       :state_abbr        => -> { Faker::Address.state_abbr },
       :state             => -> { Faker::Address.state },
       :city              => -> { Faker::Address.city },
+      :full_address      => -> { Faker::Address.full_address },
       :latitude          => -> { Faker::Address.latitude },
       :longitude         => -> { Faker::Address.longitude },
       :username          => -> { Faker::Internet.user_name },
       :boolean           => -> { [true, false ].sample },
-      :school            => -> { Faker::University.name }
+      :school            => -> { Faker::University.name },
+      :bs                => -> { Faker::Company.bs },
+      :phone_number      => -> { Faker::PhoneNumber.phone_number }
     }
   end
 end
 
-
 ActiveSupport.on_load(:active_record) do
   extend ActsAsScrubbable::Scrubbable
 end

lib/acts_as_scrubbable/scrub.rb

@@ -1,23 +1,29 @@
 module ActsAsScrubbable
   module Scrub
-
     def scrub!
       return unless self.class.scrubbable?
 
       run_callbacks(:scrub) do
+        if self.class.sterilizable?
+          self.destroy!
+          next
+        end
+
         _updates = {}
 
         scrubbable_fields.each do |_field, value|
           unless self.respond_to?(_field)
             raise ArgumentError, "#{self.class} do not respond to #{_field}"
           end
-          next if self.send(_field).blank?
+          next if self.send(_field).blank? || value == :skip
 
           if ActsAsScrubbable.scrub_map.keys.include?(value)
             _updates[_field] = ActsAsScrubbable.scrub_map[value].call
+          elsif value == :wipe
+            _updates[_field] = nil
           else
-            puts "Undefined scrub: #{value} for #{self.class}#{_field}"
-           end
+            puts "Undefined scrub: #{value} for #{self.class}.#{_field}"
+          end
         end
 
         self.update_columns(_updates) unless _updates.empty?

lib/acts_as_scrubbable/scrubbable.rb

@@ -1,36 +1,35 @@
 module ActsAsScrubbable
   module Scrubbable
-
-
     def scrubbable?
       false
     end
 
+    def acts_as_scrubbable(scrub_type=:scrub, *scrubbable_fields, **mapped_fields)
+      unless self.respond_to?(:scrubbable_fields)
+        class_attribute :scrubbable_fields
+        self.scrubbable_fields = {}
+      end
 
-    def acts_as_scrubbable(*scrubbable_fields, **mapped_fields)
-
-      class_attribute :scrubbable_fields
-
-      self.scrubbable_fields = {}
-      scrubbable_fields.each do |_field|
-        self.scrubbable_fields[_field] = _field
+      unless self.respond_to?(:sterilizable?)
+        class_attribute :sterilizable
+        self.sterilizable = scrub_type == :sterilize
       end
 
-      mapped_fields.each do |_field|
-        self.scrubbable_fields[_field.first] = _field.last
+      scrubbable_fields.each do |field_name|
+        self.scrubbable_fields[field_name] = scrub_type == :scrub ? field_name : scrub_type
       end
 
+      mapped_fields.each { |field_name, field_type| self.scrubbable_fields[field_name] = field_type }
+
       class_eval do
         define_callbacks :scrub
 
         def self.scrubbable?
           true
         end
-
       end
 
       include Scrub
     end
-
   end
 end

lib/acts_as_scrubbable/tasks.rb

@@ -2,33 +2,34 @@
 require 'rake'
 
 namespace :scrub do
-
   desc "scrub all"
   task all: :environment do
-
     require 'highline/import'
     require 'term/ansicolor'
     require 'logger'
     require 'parallel'
 
-
     include Term::ANSIColor
 
     @logger = Logger.new($stdout)
     @logger.formatter = proc do |severity, datetime, progname, msg|
-       "#{datetime}: [#{severity}] - #{msg}\n"
+      "#{datetime}: [#{severity}] - #{msg}\n"
     end
 
-    db_host = ActiveRecord::Base.connection_config[:host]
-    db_name = ActiveRecord::Base.connection_config[:database]
+    if ENV["SKIP_BEFOREHOOK"].blank?
+      @logger.info "Running before hook".red
+      ActsAsScrubbable.execute_before_hook
+    end
+
+    db_host, db_name = ActiveRecord::Base.connection_config.values_at(:host, :database)
 
     @logger.warn "Please verify the information below to continue".red
     @logger.warn "Host: ".red + " #{db_host}".white
     @logger.warn "Database: ".red + "#{db_name}".white
 
     unless ENV["SKIP_CONFIRM"] == "true"
-
       answer = ask("Type '#{db_host}' to continue. \n".red + '-> '.white)
+
       unless answer == db_host
         @logger.error "exiting ...".red
         exit
@@ -41,21 +42,17 @@
 
     @total_scrubbed = 0
 
-    ar_classes = ActiveRecord::Base.descendants.select{|d| d.scrubbable? }.sort_by{|d| d.to_s }
-
+    ar_classes = ActiveRecord::Base.descendants.select(&:scrubbable?).sort_by(&:to_s)
 
     # if the ENV variable is set
-
     unless ENV["SCRUB_CLASSES"].blank?
       class_list = ENV["SCRUB_CLASSES"].split(",")
-      class_list = class_list.map {|_class_str| _class_str.constantize }
-      ar_classes = ar_classes & class_list
+      ar_classes &= class_list.map {|_class_str| _class_str.constantize }
     end
 
     @logger.info "Srubbable Classes: #{ar_classes.join(', ')}".white
 
     Parallel.each(ar_classes) do |ar_class|
-
       # Removing any find or initialize callbacks from model
       ar_class.reset_callbacks(:initialize)
       ar_class.reset_callbacks(:find)
@@ -65,10 +62,12 @@
       scrubbed_count = 0
 
       ActiveRecord::Base.connection_pool.with_connection do
-        if ar_class.respond_to?(:scrubbable_scope)
-          relation = ar_class.send(:scrubbable_scope)
-        else
-          relation = ar_class.all
+        relation = ar_class.respond_to?(:scrubbable_scope) ? ar_class.send(:scrubbable_scope) : ar_class.all
+
+        if relation.sterilizable?
+          scrubbed_count += relation.count
+          relation.delete_all
+          next
         end
 
         relation.find_in_batches(batch_size: 1000) do |batch|
@@ -83,6 +82,7 @@
 
       @logger.info "#{scrubbed_count} #{ar_class} objects scrubbed".blue
     end
+
     ActiveRecord::Base.connection.verify!
 
     if ENV["SKIP_AFTERHOOK"].blank?

spec/db/schema.rb

@@ -1,9 +1,13 @@
 ActiveRecord::Schema.define(version: 20150421224501) do
-
   create_table "scrubbable_models", force: true do |t|
     t.string   "first_name"
+    t.string   "middle_name"
+    t.string   "last_name"
     t.string   "address1"
     t.string   "lat"
   end
 
+  create_table "sterilizable_models", force: true do |t|
+    t.string   "irrelevant"
+  end
 end

spec/lib/acts_as_scrubbable/scrub_spec.rb

@@ -1,11 +1,10 @@
 require 'spec_helper'
 
 RSpec.describe ActsAsScrubbable::Scrub do
-
   describe '.scrub' do
-
     # update_columns cannot be run on a new record
     subject{ ScrubbableModel.new }
+
     before(:each) { subject.save }
 
     it 'changes the first_name attribute when scrub is run' do
@@ -31,10 +30,34 @@
       expect(subject.address1).to be_nil
     end
 
+    it "doesn't update the field if the scrub type is `:skip`" do
+      subject.middle_name = "Edward"
+      subject.save
+      subject.scrub!
+      expect(subject.middle_name).to eq "Edward"
+    end
+
+    it "updates the field to nil if the scrub type is :wipe" do
+      subject.last_name = "Cortéz"
+      subject.save
+      subject.scrub!
+      expect(subject.last_name).to be_nil
+    end
+
     it 'runs scrub callbacks' do
       subject.scrub!
       expect(subject.scrubbing_begun).to be(true)
       expect(subject.scrubbing_finished).to be(true)
     end
+
+    context 'when sterilizable? is true' do
+      subject { SterilizableModel.new }
+
+      it 'deletes all records' do
+        subject.save
+        subject.scrub!
+        expect(subject.class.all).to be_empty
+      end
+    end
   end
 end