acts_as_scrubbable 1.1.1 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb73960ded68e0d1a181ea4bf86300ae30dccb3e29330e63ddc8cae835662750
-  data.tar.gz: 534cdd721d48284f9d714093f307108f0c12ac13ef9636bd28b08745f984fcc9
+  metadata.gz: 98b03e06478fe5c46d1be95047d60b28b91f3e21699743940e18ae0ee6ac8075
+  data.tar.gz: 28e6b08a628f43b121b4419b1571466f4810c9ad619849ce8f1b7bdc7700a658
 SHA512:
-  metadata.gz: 8685741230ee6f515b9b5738dd5b32772b66f513f991f19fe95d0db2dfcb6414f3424d1a28218e4f2b5a285bb6a0b739ce6446e2bfd569023caf1dc432ec9924
-  data.tar.gz: 4883b89adccb21c37572a3e4aa98fba58b19765d356748875921ab877c6bcc4a201b9c798f38777d8ac99cd46c0b6c4d27aac2595657d03c6199fdcc012fe69b
+  metadata.gz: 74246e4b9ea4209288e2709cf86a0b35e8d5f4abc1f7548c6a5cac4d628fbfc11c1d5a69c61d2de357748e4b6157a107ad7bc34551c3734f9d1630f62b0986e2
+  data.tar.gz: 4c5407c1f0689663ff28562880784b89442f1bce5d0cdb26e9ae0c089d4a0435ac516b692399dd8eb4cf15a115c771545bad2367aa75a8b0e9b727e6dcc43fe6

data/.gitignore

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

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

@@ -2,40 +2,28 @@ require "parallel"
 
 module ActsAsScrubbable
   class ParallelTableScrubber
-    def initialize(ar_class)
+    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 scrub(num_batches:)
+    def each_query
       # Removing any find or initialize callbacks from model
       ar_class.reset_callbacks(:initialize)
       ar_class.reset_callbacks(:find)
 
-      queries = parallel_queries(ar_class: ar_class, num_batches: num_batches)
-      scrubbed_count = Parallel.map(queries) { |query|
-        scrubbed_count = 0
-        ActiveRecord::Base.connection_pool.with_connection do
-          relation = ar_class
-          relation = relation.send(:scrubbable_scope) if ar_class.respond_to?(:scrubbable_scope)
-          relation.where(query).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
-        scrubbed_count
-      }.reduce(:+)
+      Parallel.map(parallel_queries) { |query|
+        yield(query)
+      }.reduce(:+) # returns the aggregated scrub count
     end
 
     private
 
-    attr_reader :ar_class
-
     # create even ID ranges for the table
-    def parallel_queries(ar_class:, num_batches:)
+    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)
@@ -45,22 +33,22 @@ module ActsAsScrubbable
       end
       return [] if num_records == 0 # no records to import
 
-      record_window_size, modulus = num_records.divmod(num_batches)
+      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_batches.times.each_with_object([]) do |_, queries|
+      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)
+        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
+        queries << { id: start_id..end_id } if end_id
         start_id = next_id(ar_class: ar_class, id: end_id || start_id)
       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,130 +1,25 @@
-
 require 'rake'
+require 'acts_as_scrubbable/task_runner'
 
 namespace :scrub do
 
   desc "scrub all scrubbable tables"
   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"
-    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
-
-    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
-
-    logger.info "Scrubbable 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
+    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
 
   desc "Scrub one table"
   task :model, [:ar_class] => :environment do |_, args|
-    require 'highline/import'
-    require 'term/ansicolor'
-    require 'logger'
-    require 'acts_as_scrubbable/parallel_table_scrubber'
-
-    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
-
-    Rails.application.eager_load! # make sure all the classes are loaded
-
-    ar_class = args[:ar_class].constantize
-    logger.info "Scrubbing #{ar_class} ...".green
-
-    num_batches = Integer(ENV.fetch("SCRUB_BATCHES", "256"))
-    scrubbed_count = ActsAsScrubbable::ParallelTableScrubber.new(ar_class).scrub(num_batches: num_batches)
-
-    logger.info "#{scrubbed_count} #{ar_class} objects scrubbed".blue
-    ActiveRecord::Base.connection.verify!
-
-    logger.info "Scrub Complete!".white
+    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.1.1'
+  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        => -> { defined? Faker::Job ? Faker::Job.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/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

@@ -30,35 +30,35 @@ RSpec.describe ActsAsScrubbable::Scrub do
         school: "Eastern Lebsack",
       }
       expect {
-        subject.scrub!
+        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,6 +11,10 @@ RSpec.configure do |config|
   config.include include NullDB::RSpec::NullifiedDatabase
 end
 
+module ImportSupport
+  def import(*, **); end
+end
+
 
 class NonScrubbableModel < ActiveRecord::Base; end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_scrubbable
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.1
 platform: ruby
 authors:
 - Samer Masry
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-15 00:00:00.000000000 Z
+date: 2021-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -226,15 +226,23 @@ 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
@@ -263,7 +271,10 @@ 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