acts_as_scrubbable 1.0.2 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a11d2fbbda7f3984de9911cba7b449d3f6c6720b17430f6511cf46407cd8a5c9
-  data.tar.gz: 69a93697794fc1c7abd9b2acd2f9c068639b04f03391b5cc028492ebdebf44a1
+  metadata.gz: 98b03e06478fe5c46d1be95047d60b28b91f3e21699743940e18ae0ee6ac8075
+  data.tar.gz: 28e6b08a628f43b121b4419b1571466f4810c9ad619849ce8f1b7bdc7700a658
 SHA512:
-  metadata.gz: 4b40343ddb3c0b7f764fd48167d3ce3c0dd2cc91f2221652f515849effd1b6da67040fe376e2543240a0efd391aa91eb0347d9e2780b184bee500ac5cad2a319
-  data.tar.gz: 18c59e0bb668fe98bbf584297d56fb41b14d2bef2e3f4e9e052b330e012a61b5eb9988ab493233db953959776390e529218bff2e0bc8203033712a48054cad7f
+  metadata.gz: 74246e4b9ea4209288e2709cf86a0b35e8d5f4abc1f7548c6a5cac4d628fbfc11c1d5a69c61d2de357748e4b6157a107ad7bc34551c3734f9d1630f62b0986e2
+  data.tar.gz: 4c5407c1f0689663ff28562880784b89442f1bce5d0cdb26e9ae0c089d4a0435ac516b692399dd8eb4cf15a115c771545bad2367aa75a8b0e9b727e6dcc43fe6

data/.gitignore

@@ -1 +1,3 @@
 Gemfile.lock
+
+.idea/*

data/Gemfile

@@ -1,5 +1,3 @@
-ruby '2.4.3'
-
 source 'https://rubygems.org'
 
 gemspec

data/README.md

@@ -97,3 +97,22 @@ ActsAsScrubbable.configure do |c|
   end
 end
 ```
+
+### UPDATE VS UPSERT
+
+By default, the scrubbing proces will run independent UPDATE statements for each scrubbed model. This can be time 
+consuming if you are scrubbing a large number of records.  As an alternative, some 
+databases support doing bulk database updates using an upsert using the INSERT command.  `activerecord-import` 
+gives us easy support for this and as such it is a requirement to using
+this feature. Some details about the implementation can be found here. https://github.com/zdennis/activerecord-import#duplicate-key-update
+
+Note that we only support the MySQL implementation at this time.
+
+To use UPSERT over UPDATE, it can be enabled by specifying the environment variable `USE_UPSERT='true'` or through configuration.
+
+```ruby
+ActsAsScrubbable.configure do |c|
+  c.use_upsert = true
+end
+```
+

data/lib/acts_as_scrubbable/ar_class_processor.rb

@@ -0,0 +1,36 @@
+require 'acts_as_scrubbable/import_processor'
+require 'acts_as_scrubbable/update_processor'
+require 'term/ansicolor'
+
+module ActsAsScrubbable
+  class ArClassProcessor
+
+    attr_reader :ar_class, :query_processor
+
+    def initialize(ar_class)
+      @ar_class = ar_class
+
+      if ActsAsScrubbable.use_upsert
+        ActsAsScrubbable.logger.info Term::ANSIColor.white("Using Upsert")
+        @query_processor = ImportProcessor.new(ar_class)
+      else
+        ActsAsScrubbable.logger.info Term::ANSIColor.white("Using Update")
+        @query_processor = UpdateProcessor.new(ar_class)
+      end
+    end
+
+    def process(num_of_batches)
+      ActsAsScrubbable.logger.info Term::ANSIColor.green("Scrubbing #{ar_class} ...")
+
+      num_of_batches = Integer(ENV.fetch("SCRUB_BATCHES", "256")) if num_of_batches.nil?
+      scrubbed_count = ActsAsScrubbable::ParallelTableScrubber.new(ar_class, num_of_batches).each_query do |query|
+        query_processor.scrub_query(query)
+      end
+
+      ActsAsScrubbable.logger.info Term::ANSIColor.blue("#{scrubbed_count} #{ar_class} objects scrubbed")
+      ActiveRecord::Base.connection.verify!
+
+      ActsAsScrubbable.logger.info Term::ANSIColor.white("Scrub Complete!")
+    end
+  end
+end

data/lib/acts_as_scrubbable/base_processor.rb

@@ -0,0 +1,28 @@
+module ActsAsScrubbable
+  module BaseProcessor
+    attr_reader :ar_class
+    private :ar_class
+
+    def initialize(ar_class)
+      @ar_class = ar_class
+    end
+
+    def scrub_query(query = nil)
+      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
+        end
+
+        relation.where(query).find_in_batches(batch_size: 1000) do |batch|
+          ActiveRecord::Base.transaction do
+            scrubbed_count += handle_batch(batch)
+          end
+        end
+      end
+      scrubbed_count
+    end
+  end
+end

data/lib/acts_as_scrubbable/import_processor.rb

@@ -0,0 +1,24 @@
+require 'acts_as_scrubbable/base_processor'
+
+module ActsAsScrubbable
+  class ImportProcessor
+    include BaseProcessor
+
+    private
+    def handle_batch(batch)
+      scrubbed_count = 0
+      batch.each do |obj|
+        _updates = obj.scrubbed_values
+        obj.assign_attributes(_updates)
+        scrubbed_count += 1
+      end
+      ar_class.import(
+        batch,
+        on_duplicate_key_update: ar_class.scrubbable_fields.keys.map { |x| "`#{x}` = values(`#{x}`)" }.join(" , "),
+        validate: false,
+        timestamps: false
+      )
+      scrubbed_count
+    end
+  end
+end

data/lib/acts_as_scrubbable/parallel_table_scrubber.rb

@@ -0,0 +1,72 @@
+require "parallel"
+
+module ActsAsScrubbable
+  class ParallelTableScrubber
+    attr_reader :ar_class, :num_of_batches
+    private :ar_class, :num_of_batches
+
+    def initialize(ar_class, num_of_batches)
+      @ar_class = ar_class
+      @num_of_batches = num_of_batches
+    end
+
+    def each_query
+      # Removing any find or initialize callbacks from model
+      ar_class.reset_callbacks(:initialize)
+      ar_class.reset_callbacks(:find)
+
+      Parallel.map(parallel_queries) { |query|
+        yield(query)
+      }.reduce(:+) # returns the aggregated scrub count
+    end
+
+    private
+
+    # create even ID ranges for the table
+    def parallel_queries
+      raise "Model is missing id column" if ar_class.columns.none? { |column| column.name == "id" }
+
+      if ar_class.respond_to?(:scrubbable_scope)
+        num_records = ar_class.send(:scrubbable_scope).count
+      else
+        num_records = ar_class.count
+      end
+      return [] if num_records == 0 # no records to import
+
+      record_window_size, modulus = num_records.divmod(num_of_batches)
+      if record_window_size < 1
+        record_window_size = 1
+        modulus = 0
+      end
+
+      start_id = next_id(ar_class: ar_class, offset: 0)
+      queries = num_of_batches.times.each_with_object([]) do |_, queries|
+        next unless start_id
+
+        end_id = next_id(ar_class: ar_class, id: start_id, offset: record_window_size - 1)
+        if modulus > 0
+          end_id = next_id(ar_class: ar_class, id: end_id)
+          modulus -= 1
+        end
+        queries << { id: start_id..end_id } if end_id
+        start_id = next_id(ar_class: ar_class, id: end_id || start_id)
+      end
+
+      # just in case new records are added since we started, extend the end ID
+      queries[-1] = ["#{ar_class.quoted_table_name}.id >= ?", queries[-1][:id].begin] if queries.any?
+
+      queries
+    end
+
+    def next_id(ar_class:, id: nil, offset: 1)
+      if ar_class.respond_to?(:scrubbable_scope)
+        collection = ar_class.send(:scrubbable_scope)
+      else
+        collection = ar_class.all
+      end
+      collection = collection.reorder(:id)
+      collection = collection.where("#{ar_class.quoted_table_name}.id >= :id", id: id) if id
+      collection.offset(offset).limit(1).pluck(:id).first
+    end
+  end
+end

data/lib/acts_as_scrubbable/scrub.rb

@@ -1,7 +1,7 @@
 module ActsAsScrubbable
   module Scrub
 
-    def scrub!
+    def scrubbed_values
       return unless self.class.scrubbable?
 
       run_callbacks(:scrub) do
@@ -20,7 +20,7 @@ module ActsAsScrubbable
            end
         end
 
-        self.update_columns(_updates) unless _updates.empty?
+        _updates
       end
     end
   end

data/lib/acts_as_scrubbable/task_runner.rb

@@ -0,0 +1,66 @@
+require 'acts_as_scrubbable/parallel_table_scrubber'
+require 'highline/import'
+require 'acts_as_scrubbable/ar_class_processor'
+require 'term/ansicolor'
+
+module ActsAsScrubbable
+  class TaskRunner
+    attr_reader :ar_classes
+    private :ar_classes
+
+    def initialize
+      @ar_classes = []
+    end
+
+    def prompt_db_configuration
+      db_host = ActiveRecord::Base.connection_config[:host]
+      db_name = ActiveRecord::Base.connection_config[:database]
+
+      ActsAsScrubbable.logger.warn Term::ANSIColor.red("Please verify the information below to continue")
+      ActsAsScrubbable.logger.warn Term::ANSIColor.red("Host: ") + Term::ANSIColor.white(" #{db_host}")
+      ActsAsScrubbable.logger.warn Term::ANSIColor.red("Database: ") + Term::ANSIColor.white("#{db_name}")
+    end
+
+    def confirmed_configuration?
+      db_host = ActiveRecord::Base.connection_config[:host]
+
+      unless ENV["SKIP_CONFIRM"] == "true"
+        answer = ask("Type '#{db_host}' to continue. \n".red + '-> '.white)
+        unless answer == db_host
+          ActsAsScrubbable.logger.error Term::ANSIColor.red("exiting ...")
+          return false
+        end
+      end
+      true
+    end
+
+    def extract_ar_classes
+      Rails.application.eager_load! # make sure all the classes are loaded
+      @ar_classes = ActiveRecord::Base.descendants.select { |d| d.scrubbable? }.sort_by { |d| d.to_s }
+
+      if ENV["SCRUB_CLASSES"].present?
+        class_list = ENV["SCRUB_CLASSES"].split(",")
+        class_list = class_list.map { |_class_str| _class_str.constantize }
+        @ar_classes = ar_classes & class_list
+      end
+    end
+
+    def set_ar_class(ar_class)
+      ar_classes << ar_class
+    end
+
+    def scrub(num_of_batches: nil)
+      Parallel.each(ar_classes) do |ar_class|
+        ActsAsScrubbable::ArClassProcessor.new(ar_class).process(num_of_batches)
+      end
+      ActiveRecord::Base.connection.verify!
+    end
+
+    def after_hooks
+      if ENV["SKIP_AFTERHOOK"].blank?
+        ActsAsScrubbable.logger.info Term::ANSIColor.red("Running after hook")
+        ActsAsScrubbable.execute_after_hook
+      end
+    end
+  end
+end

data/lib/acts_as_scrubbable/tasks.rb

@@ -1,96 +1,25 @@
-
 require 'rake'
+require 'acts_as_scrubbable/task_runner'
 
 namespace :scrub do
 
-  desc "scrub all"
+  desc "scrub all scrubbable tables"
   task all: :environment do
+    task_runner = ActsAsScrubbable::TaskRunner.new
+    task_runner.prompt_db_configuration
+    exit unless task_runner.confirmed_configuration?
+    task_runner.extract_ar_classes
+    task_runner.scrub(num_of_batches: 1)
+    task_runner.after_hooks
+  end
 
-    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"
-    end
-
-    db_host = ActiveRecord::Base.connection_config[:host]
-    db_name = ActiveRecord::Base.connection_config[: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
-      end
-    end
-
-    @logger.warn "Scrubbing classes".red
-
-    Rails.application.eager_load! # make sure all the classes are loaded
-
-    @total_scrubbed = 0
-
-    ar_classes = ActiveRecord::Base.descendants.select{|d| d.scrubbable? }.sort_by{|d| d.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
-    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)
-
-      @logger.info "Scrubbing #{ar_class} ...".green
-
-      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
-        end
-
-        relation.find_in_batches(batch_size: 1000) do |batch|
-          ActiveRecord::Base.transaction do
-            batch.each do |obj|
-              obj.scrub!
-              scrubbed_count += 1
-            end
-          end
-        end
-      end
-
-      @logger.info "#{scrubbed_count} #{ar_class} objects scrubbed".blue
-    end
-    ActiveRecord::Base.connection.verify!
-
-    if ENV["SKIP_AFTERHOOK"].blank?
-      @logger.info "Running after hook".red
-      ActsAsScrubbable.execute_after_hook
-    end
-
-    @logger.info "Scrub Complete!".white
+  desc "Scrub one table"
+  task :model, [:ar_class] => :environment do |_, args|
+    task_runner = ActsAsScrubbable::TaskRunner.new
+    task_runner.prompt_db_configuration
+    exit unless task_runner.confirmed_configuration?
+    task_runner.set_ar_class(args[:ar_class].constantize)
+    task_runner.scrub
   end
 end
 

data/lib/acts_as_scrubbable/update_processor.rb

@@ -0,0 +1,18 @@
+require 'acts_as_scrubbable/base_processor'
+
+module ActsAsScrubbable
+  class UpdateProcessor
+    include BaseProcessor
+
+    private
+    def handle_batch(batch)
+      scrubbed_count = 0
+      batch.each do |obj|
+        _updates = obj.scrubbed_values
+        obj.update_columns(_updates) unless _updates.empty?
+        scrubbed_count += 1
+      end
+      scrubbed_count
+    end
+  end
+end

data/lib/acts_as_scrubbable/version.rb

@@ -1,3 +1,3 @@
 module ActsAsScrubbable
-  VERSION = '1.0.2'
+  VERSION = '1.2.1'
 end

data/lib/acts_as_scrubbable.rb

@@ -2,59 +2,76 @@ require 'active_record'
 require 'active_record/version'
 require 'active_support/core_ext/module'
 require 'acts_as_scrubbable/tasks'
-
+require 'term/ansicolor'
+require 'logger'
 
 module ActsAsScrubbable
+  extend self
   extend ActiveSupport::Autoload
+  include Term::ANSIColor
 
   autoload :Scrubbable
   autoload :Scrub
   autoload :VERSION
 
+  attr_accessor :use_upsert
+
+  class << self
+    def configure(&block)
+      self.use_upsert = ENV["USE_UPSERT"] == "true"
 
-  def self.configure(&block)
-    yield self
+      yield self
+    end
   end
 
-  def self.after_hook(&block)
+  def after_hook(&block)
     @after_hook = block
   end
 
-  def self.execute_after_hook
+  def execute_after_hook
     @after_hook.call if @after_hook
   end
 
-  def self.add(key, value)
+  def logger
+    @logger ||= begin
+                  loggger = Logger.new($stdout)
+                  loggger.formatter = proc do |severity, datetime, progname, msg|
+                    "#{datetime}: [#{severity}] - #{msg}\n"
+                  end
+                  loggger
+                end
+  end
+
+  def add(key, value)
     ActsAsScrubbable.scrub_map[key] = value
   end
 
-  def self.scrub_map
+  def scrub_map
     require 'faker'
 
     @_scrub_map ||= {
-      :first_name        => -> { Faker::Name.first_name },
-      :last_name         => -> { Faker::Name.last_name },
-      :middle_name       => -> { Faker::Name.name },
-      :name              => -> { Faker::Name.name },
-      :email             => -> { Faker::Internet.email },
-      :name_title        => -> { Faker::Name.title },
-      :company_name      => -> { Faker::Company.name },
-      :street_address    => -> { Faker::Address.street_address },
+      :first_name => -> { Faker::Name.first_name },
+      :last_name => -> { Faker::Name.last_name },
+      :middle_name => -> { Faker::Name.name },
+      :name => -> { Faker::Name.name },
+      :email => -> { Faker::Internet.email },
+      :name_title => -> { defined? Faker::Job ? Faker::Job.title : Faker::Name.title },
+      :company_name => -> { Faker::Company.name },
+      :street_address => -> { Faker::Address.street_address },
       :secondary_address => -> { Faker::Address.secondary_address },
-      :zip_code          => -> { Faker::Address.zip_code },
-      :state_abbr        => -> { Faker::Address.state_abbr },
-      :state             => -> { Faker::Address.state },
-      :city              => -> { Faker::Address.city },
-      :latitude          => -> { Faker::Address.latitude },
-      :longitude         => -> { Faker::Address.longitude },
-      :username          => -> { Faker::Internet.user_name },
-      :boolean           => -> { [true, false ].sample },
-      :school            => -> { Faker::University.name }
+      :zip_code => -> { Faker::Address.zip_code },
+      :state_abbr => -> { Faker::Address.state_abbr },
+      :state => -> { Faker::Address.state },
+      :city => -> { Faker::Address.city },
+      :latitude => -> { Faker::Address.latitude },
+      :longitude => -> { Faker::Address.longitude },
+      :username => -> { Faker::Internet.user_name },
+      :boolean => -> { [true, false].sample },
+      :school => -> { Faker::University.name }
     }
   end
 end
 
-
 ActiveSupport.on_load(:active_record) do
   extend ActsAsScrubbable::Scrubbable
 end

data/spec/db/schema.rb

@@ -2,8 +2,23 @@ ActiveRecord::Schema.define(version: 20150421224501) do
 
   create_table "scrubbable_models", force: true do |t|
     t.string   "first_name"
+    t.string   "last_name"
+    t.string   "middle_name"
+    t.string   "name"
+    t.string   "email"
+    t.string   "title"
+    t.string   "company_name"
     t.string   "address1"
+    t.string   "address2"
+    t.string   "zip_code"
+    t.string   "state"
+    t.string   "state_short"
+    t.string   "city"
     t.string   "lat"
+    t.string   "lon"
+    t.string   "username"
+    t.boolean  "active"
+    t.string   "school"
   end
 
 end

data/spec/lib/acts_as_scrubbable/ar_class_processor_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+RSpec.describe ActsAsScrubbable::ArClassProcessor do
+  let(:ar_class) { ScrubbableModel }
+
+  describe "#initialize" do
+    subject { described_class.new(ar_class) }
+
+    context "with upsert enabled" do
+      before do
+        allow(ActsAsScrubbable).to receive(:use_upsert).and_return(true)
+      end
+
+      it "includes the ImportProcessor module" do
+        expect(subject.query_processor).to be_kind_of(ActsAsScrubbable::ImportProcessor)
+      end
+    end
+
+    context "without upsert enabled" do
+      it "includes the UpdateProcessor module" do
+        expect(subject.query_processor).to be_kind_of(ActsAsScrubbable::UpdateProcessor)
+      end
+    end
+  end
+
+  describe "#process" do
+    let(:num_of_batches) { nil }
+    let(:query) { nil }
+    let(:parallel_table_scrubber_mock) { instance_double("ParallelTableScrubber") }
+    let(:update_processor_mock) { instance_double("UpdateProcessor", scrub_query: nil) }
+    subject { described_class.new(ar_class) }
+
+    before do
+      allow(ActsAsScrubbable::ParallelTableScrubber).to receive(:new).and_return(parallel_table_scrubber_mock)
+      allow(ActsAsScrubbable::UpdateProcessor).to receive(:new).and_return(update_processor_mock)
+      allow(parallel_table_scrubber_mock).to receive(:each_query).and_yield(query)
+    end
+
+    it "calls the expected helper classes with the expected batch size" do
+      expect(ActiveRecord::Base.connection).to receive(:verify!)
+      expect(update_processor_mock).to receive(:scrub_query).with(query)
+      subject.process(num_of_batches)
+      expect(ActsAsScrubbable::ParallelTableScrubber).to have_received(:new).with(ar_class, 256)
+    end
+
+    context "with an inputted batch size" do
+      let(:num_of_batches) { 10 }
+
+      it "calls ParallelTableScrubber with the passed batch size" do
+        subject.process(num_of_batches)
+        expect(ActsAsScrubbable::ParallelTableScrubber).to have_received(:new).with(ar_class, num_of_batches)
+      end
+    end
+
+  end
+end

data/spec/lib/acts_as_scrubbable/import_processor_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+RSpec.describe ActsAsScrubbable::ImportProcessor do
+  let(:ar_class) { ScrubbableModel }
+  let(:model) { ar_class.new }
+  subject { described_class.new(ar_class) }
+
+  before do
+    ar_class.extend(ImportSupport)
+  end
+
+  describe "#handle_batch" do
+    it "calls import with the correct parameters" do
+      expect(model).to receive(:scrubbed_values).and_call_original
+      expect(ar_class).to receive(:import).with(
+        [model],
+        on_duplicate_key_update: "`first_name` = values(`first_name`) , `last_name` = values(`last_name`) , `middle_name` = values(`middle_name`) , `name` = values(`name`) , `email` = values(`email`) , `company_name` = values(`company_name`) , `zip_code` = values(`zip_code`) , `state` = values(`state`) , `city` = values(`city`) , `username` = values(`username`) , `school` = values(`school`) , `title` = values(`title`) , `address1` = values(`address1`) , `address2` = values(`address2`) , `state_short` = values(`state_short`) , `lat` = values(`lat`) , `lon` = values(`lon`) , `active` = values(`active`)",
+        validate: false,
+        timestamps: false
+      )
+
+      expect(subject.send(:handle_batch, [model])).to eq 1
+    end
+  end
+end

data/spec/lib/acts_as_scrubbable/scrub_spec.rb

@@ -5,34 +5,60 @@ RSpec.describe ActsAsScrubbable::Scrub do
   describe '.scrub' do
 
     # update_columns cannot be run on a new record
-    subject{ ScrubbableModel.new }
+    subject { ScrubbableModel.new }
     before(:each) { subject.save }
 
+    it 'scrubs all columns' do
+      subject.attributes = {
+        first_name: "Ted",
+        last_name: "Lowe",
+        middle_name: "Cassidy",
+        name: "Miss Vincenzo Smitham",
+        email: "trentdibbert@wiza.com",
+        title: "Internal Consultant",
+        company_name: "Greenfelder, Collier and Lesch",
+        address1: "86780 Watsica Flats",
+        address2: "Apt. 913",
+        zip_code: "49227",
+        state: "Ohio",
+        state_short: "OH",
+        city: "Port Hildegard",
+        lat: -79.5855309778974,
+        lon: 13.517352691513906,
+        username: "oscar.hermann",
+        active: false,
+        school: "Eastern Lebsack",
+      }
+      expect {
+        subject.scrubbed_values
+      }.not_to raise_error
+    end
+
     it 'changes the first_name attribute when scrub is run' do
       subject.first_name = "Ted"
       allow(Faker::Name).to receive(:first_name).and_return("John")
-      subject.scrub!
-      expect(subject.first_name).to eq "John"
+      _updates = subject.scrubbed_values
+      expect(_updates[:first_name]).to eq "John"
     end
 
     it 'calls street address on faker and updates address1' do
       subject.address1 = "123 abc"
       subject.save
       allow(Faker::Address).to receive(:street_address).and_return("1 Embarcadero")
-      subject.scrub!
-      expect(subject.address1).to eq "1 Embarcadero"
+      _updates = subject.scrubbed_values
+      expect(_updates[:address1]).to eq "1 Embarcadero"
     end
 
     it "doesn't update the field if it's blank" do
       subject.address1 = nil
       subject.save
       allow(Faker::Address).to receive(:street_address).and_return("1 Embarcadero")
-      subject.scrub!
-      expect(subject.address1).to be_nil
+      _updates = subject.scrubbed_values
+      expect(_updates[:address1]).to be_nil
     end
 
     it 'runs scrub callbacks' do
-      subject.scrub!
+      subject.scrubbed_values
       expect(subject.scrubbing_begun).to be(true)
       expect(subject.scrubbing_finished).to be(true)
     end

data/spec/lib/acts_as_scrubbable/update_processor_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+RSpec.describe ActsAsScrubbable::UpdateProcessor do
+  let(:ar_class) { ScrubbableModel }
+  let(:model) { ar_class.create(
+    first_name: "Ted",
+    last_name: "Lowe",
+  ) }
+  subject { described_class.new(ar_class) }
+
+  describe "#handle_batch" do
+    it "calls update with the updated attributes" do
+      expect(model).to receive(:scrubbed_values).and_call_original
+      expect(model).to receive(:update_columns).and_call_original
+
+      expect(subject.send(:handle_batch, [model])).to eq 1
+    end
+  end
+end

data/spec/support/database.rb

@@ -11,11 +11,32 @@ RSpec.configure do |config|
   config.include include NullDB::RSpec::NullifiedDatabase
 end
 
+module ImportSupport
+  def import(*, **); end
+end
+
 
 class NonScrubbableModel < ActiveRecord::Base; end
 
 class ScrubbableModel < ActiveRecord::Base
-  acts_as_scrubbable :first_name, :address1 => :street_address, :lat => :latitude
+  acts_as_scrubbable :first_name,
+    :last_name,
+    :middle_name,
+    :name,
+    :email,
+    :company_name,
+    :zip_code,
+    :state,
+    :city,
+    :username,
+    :school,
+    :title => :name_title,
+    :address1 => :street_address,
+    :address2 => :secondary_address,
+    :state_short => :state_abbr,
+    :lat => :latitude,
+    :lon => :longitude,
+    :active => :boolean
   attr_accessor :scrubbing_begun, :scrubbing_finished
   set_callback :scrub, :before do
     self.scrubbing_begun = true

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_scrubbable
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.2.1
 platform: ruby
 authors:
 - Samer Masry
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-08-22 00:00:00.000000000 Z
+date: 2021-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -226,21 +226,30 @@ files:
 - README.md
 - acts_as_scrubbable.gemspec
 - lib/acts_as_scrubbable.rb
+- lib/acts_as_scrubbable/ar_class_processor.rb
+- lib/acts_as_scrubbable/base_processor.rb
+- lib/acts_as_scrubbable/import_processor.rb
+- lib/acts_as_scrubbable/parallel_table_scrubber.rb
 - lib/acts_as_scrubbable/scrub.rb
 - lib/acts_as_scrubbable/scrubbable.rb
+- lib/acts_as_scrubbable/task_runner.rb
 - lib/acts_as_scrubbable/tasks.rb
+- lib/acts_as_scrubbable/update_processor.rb
 - lib/acts_as_scrubbable/version.rb
 - spec/db/database.yml
 - spec/db/schema.rb
+- spec/lib/acts_as_scrubbable/ar_class_processor_spec.rb
+- spec/lib/acts_as_scrubbable/import_processor_spec.rb
 - spec/lib/acts_as_scrubbable/scrub_spec.rb
 - spec/lib/acts_as_scrubbable/scrubbable_spec.rb
+- spec/lib/acts_as_scrubbable/update_processor_spec.rb
 - spec/spec_helper.rb
 - spec/support/database.rb
 homepage: https://github.com/smasry/acts_as_scrubbable
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -255,15 +264,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Scrubbing data made easy
 test_files:
 - spec/db/database.yml
 - spec/db/schema.rb
+- spec/lib/acts_as_scrubbable/ar_class_processor_spec.rb
+- spec/lib/acts_as_scrubbable/import_processor_spec.rb
 - spec/lib/acts_as_scrubbable/scrub_spec.rb
 - spec/lib/acts_as_scrubbable/scrubbable_spec.rb
+- spec/lib/acts_as_scrubbable/update_processor_spec.rb
 - spec/spec_helper.rb
 - spec/support/database.rb