anonymizable 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f168893c5332b239f219373fc9534013f56717d4
+  data.tar.gz: 2ce8b584bb2c0ff8f05279d49d5482a78a1d3d04
+SHA512:
+  metadata.gz: 76ff17fe8175c8842031120ccc8269694ed1e9ec316ed43f6373176ff50b457d268b6d74ae571654e8df67d9954549a947aa980c3814e416133e8c2833a99bbe
+  data.tar.gz: a386282d9d3a9807fd3cab27b2ae5a5d981095545dda91fa006498dd08a7d1aa2601beb6179869578b8f0254980a71d404ae2cb414abe0f5ac0df8cc6b746a59

data/.gitignore

@@ -0,0 +1,13 @@
+*.gem
+*.swp
+.bundle
+.config
+.rvmrc
+.DS_Store
+Gemfile.lock
+spec/debug.log
+spec/*.db
+coverage
+pkg
+rdoc
+TODO

data/.pryrc

@@ -0,0 +1,32 @@
+require 'yaml'
+require 'anonymizable'
+
+def user
+  with_retries do
+    @user ||= User.create! first_name: "Created", last_name: "User", email: "created.user@foobar.com", password: "foobar", role: role
+  end
+end
+
+def role
+  with_retries do
+    @role ||= Role.create! name: "user"
+  end
+end
+
+def with_retries(attempts=1, &block)
+  retries = 1
+  begin
+    yield
+  rescue NameError
+    load_models
+    retry unless retries > attempts
+    retries += 1
+  end
+end
+
+def load_models
+  config = YAML::load(IO.read(File.join(Dir.pwd, "spec/database.yml")))
+  ActiveRecord::Base.establish_connection(config['sqlite3'])
+  load(File.join(Dir.pwd, "spec/schema.rb"))
+  Dir.glob(File.join(Dir.pwd, "/spec/models/*.rb")) { |path| require path }
+end

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,203 @@
+# Anonymizable
+
+Anonymizable adds the ability to anonymize or delete data in your ActiveRecord models. A good use case for this is when you want to remove user accounts but for statistical or data integrity reasons you want to keep the actual records in your database.
+
+## Supported Ruby/Rails Versions
+
+Anonymizer supports all 2.x versions of Ruby and all Rails versions between 3.2.x and 4.x.
+
+## Installation
+
+```ruby
+gem 'anonymizable'
+```
+and run `bundle install` from your shell.
+
+## Usage
+
+### Nullification
+
+```ruby
+class User < ActiveRecord::Base
+
+  anonymizable do
+    attributes :first_name, :last_name
+  end
+
+end
+```
+
+This adds an instance method ```User#anonymize!``` which in this case just nullifies the ```first_name``` and```last_name``` database columns.
+
+The ```anonymize!``` method is defined as private by default, but you can make it public by passing the ```public``` option:
+
+```ruby
+  anonymizable public: true do
+    attributes :first_name, :last_name
+  end
+```
+
+### Anonymization
+
+By passing to ```attributes``` a hash as the last argument, you can anonymize columns using a Proc or instance method.
+
+```ruby
+anonymizable public: true do
+
+  attributes  :first_name, :last_name,
+              email: Proc.new { |u| "anonymized.user.#{u.id}@foobar.com" }, 
+              password: :random_password
+end
+```
+
+In this example, the ```email``` column will be anonymized by calling the block and passing the ```User``` object. The ```password``` column will be anonymized using the return value of ```User#random_password```, which can be defined as either a public or private instance method. The user object is not passed as an argument in this case, but can be accessed by ```self```.
+
+### Associations
+
+ActiveRecord associations can either be anonymized, destroyed, or deleted. 
+
+```ruby
+anonymizable public: true do
+
+  attributes  :first_name, :last_name,
+              email: Proc.new { |u| "anonymized.user.#{u.id}@foobar.com" }, 
+              password: :random_password
+
+  associations do
+    anonymize :posts, :comments
+    delete    :avatar, :likes
+    destroy   :images
+  end
+
+end
+```
+
+In the example above, the ```anonymize!``` method will be called on each ```Post``` and ```Comment``` association. As such, anonymization must be defined on both of these classes:
+
+```ruby
+class Post < ActiveRecord::Base
+
+  anonymizable :user_id
+
+end
+```
+
+```ruby
+class Comment < ActiveRecord::Base
+
+  anonymizable :user_id
+
+end
+```
+
+In this case, the ```user_id``` column is nullified on any of the user's posts or comments.
+
+
+**All operations on columns and attributes are performed in a database transaction which will rollback all changes if an error occurs during anonymization.**
+
+
+### Guards
+
+You can declare a Proc or method to use as a guard against anonymization. If the Proc or method returns ```ruby false``` or ```ruby nil```, anonymization will short circuit.
+
+```ruby
+  anonymizable public: true do
+    only_if :can_anonymize?
+
+    attributes  :first_name, :last_name,
+                email: Proc.new { |u| "anonymized.user.#{u.id}@foobar.com" }, 
+                password: :random_password
+
+    associations do
+      anonymize :posts, :comments
+      delete    :avatar, :likes
+      destroy   :images
+    end
+
+  end
+
+  def can_anonymize?
+    !admin?
+  end
+```
+
+### Preventing Deletion
+
+You can prohibit the deletion of objects on which anonymizable is configured by passing the ```raise_on_delete``` option:
+
+```ruby
+  anonymizable raise_on_delete: true do
+
+    attributes  :first_name, :last_name,
+                email: Proc.new { |u| "anonymized.user.#{u.id}@foobar.com" }, 
+                password: :random_password
+
+    associations do
+      anonymize :posts, :comments
+      delete    :avatar, :likes
+      destroy   :images
+    end
+
+  end
+```
+
+```ruby
+  > user.delete
+  Anonymizable::DeleteProhibitedError: destroy is prohibited on #<User:0x007f8d125e4948>
+```
+
+```ruby
+  > user.destroy
+  Anonymizable::DestroyProhibitedError: destroy is prohibited on #<User:0x007f8d125e4948>
+```
+
+### Callbacks
+
+You can declare callbacks that run after anonymization is complete.
+
+```ruby
+anonymizable public: true do
+
+  attributes  :first_name, :last_name,
+              email: Proc.new { |u| "anonymized.user.#{u.id}@foobar.com" }, 
+              password: :random_password
+
+  associations do
+    anonymize :posts, :comments
+    delete    :avatar, :likes
+    destroy   :images
+  end
+
+  after :email_admin, Proc.new { |original_attrs| log("Attributes changed: #{original_attrs}") }
+end
+```
+
+Each method or Proc is passed the value of the object's pre-anonymization attributes as a hash. You would define a method on ```User`` that receives the attribute hash:
+
+```ruby
+ def email_admin(original_attributes)
+    AdminMailer.user_anonymized(original_attributes["email"])
+  end
+```
+
+It is worth noting that these callbacks are run after the database transaction commits, so an error in a callback does not trigger a database rollback.
+
+### Short Syntax
+
+As intimated in the ```Post``` and ```Comment``` examples above, you can call ```anonymize``` without a block, but rather just with an array of columns to nullify and/or anonymization hash. In this case the ```Model#anonymize!``` will be private.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+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/anonymizable.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.expand_path("../lib", __FILE__)
+require "anonymizable/version"
+
+Gem::Specification.new do |s|
+  s.name          = "anonymizable"
+  s.description   = "Delete data without deleting it"
+  s.summary       = "Anonymize columns in ActiveRecord models"
+  s.homepage      = "https://github.com/47primes/anonymizable"
+  s.authors       = ["Mike Bradford"]
+  s.email         = ["mbradford@47primes.com"]
+  s.version       = Anonymizable::VERSION
+  s.platform      = Gem::Platform::RUBY
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+  s.add_dependency "activerecord", ">= 3.2", "< 5.0"
+
+  s.add_development_dependency "rspec", "~> 3.2"
+  s.add_development_dependency "sqlite3", "~> 1.3"
+  s.add_development_dependency "database_cleaner", "~> 1.0"
+  s.add_development_dependency "factory_girl", "~> 4.5"
+  s.add_development_dependency "pry", "~> 0.10"
+end

data/lib/anonymizable.rb

@@ -0,0 +1,150 @@
+require "active_record"
+require "anonymizable/configuration"
+
+module Anonymizable
+  AnonymizeError = Class.new(StandardError)
+  DeleteProhibitedError = Class.new(StandardError)
+  DestroyProhibitedError = Class.new(StandardError)
+
+  def self.extended(klass)
+
+    klass.class_eval do
+
+      class << self
+        attr_reader :anonymization_config
+
+        def anonymizable(*attrs, &block)
+          @anonymization_config ||= Configuration.new(self)
+          if block
+            options = attrs.extract_options!
+            @anonymization_config.send(:public) if options[:public] == true
+            @anonymization_config.send(:raise_on_delete) if options[:raise_on_delete] == true
+            @anonymization_config.instance_eval(&block)
+          else
+            @anonymization_config.attributes(*attrs)
+          end
+
+          define_method(:anonymize!) do
+            return false unless _can_anonymize?
+
+            original_attributes = attributes.dup
+            transaction do
+              _anonymize_columns
+              _anonymize_associations
+              _delete_associations
+              _destroy_associations
+            end
+            _perform_post_anonymization_callbacks(original_attributes)
+            true
+          end
+
+          unless @anonymization_config.public?
+            self.send(:private, :anonymize!)
+          end
+
+          if @anonymization_config.raise_on_delete?
+            define_method(:delete) do
+              raise DeleteProhibitedError.new("delete is prohibited on #{self}")
+            end
+
+            define_method(:destroy) do
+              raise DestroyProhibitedError.new("destroy is prohibited on #{self}")
+            end
+          end
+        end
+      end
+
+      private
+
+        def _can_anonymize?
+          if self.class.anonymization_config.guard
+            if self.class.anonymization_config.guard.respond_to?(:call)
+              return self.class.anonymization_config.guard.call(self)
+            else
+              return self.send self.class.anonymization_config.guard
+            end
+          end
+
+          true
+        end
+
+        def _anonymize_columns
+          nullify_hash    = self.class.anonymization_config.attrs_to_nullify.inject({}) {|memo, attr| memo[attr] = nil; memo}
+          anonymize_hash  = self.class.anonymization_config.attrs_to_anonymize.inject({}) do |memo, array|
+                              attr, proc = array
+                              if proc.respond_to?(:call)
+                                memo[attr] = proc.call(self)
+                              else
+                                memo[attr] = self.send(proc)
+                              end
+                              memo
+                            end
+
+          update_hash = nullify_hash.merge anonymize_hash
+
+          self.class.where(id: self.id).update_all(update_hash) unless update_hash.empty?
+        end
+
+        def _anonymize_by_call
+          return if self.class.anonymization_config.attrs_to_anonymize.empty?
+          update_hash = self.class.anonymization_config.attrs_to_anonymize.inject({}) do |memo, array|
+            attr, proc = array
+            if proc.respond_to?(:call)
+              memo[attr] = proc.call(self)
+            else
+              memo[attr] = self.send(proc)
+            end
+            memo
+          end
+          self.class.where(id: self.id).update_all(update_hash)
+        end
+
+        def _anonymize_associations
+          self.class.anonymization_config.associations_to_anonymize.each do |association|
+            if self.send(association).respond_to?(:each)
+              self.send(association).each {|a| a.send(:anonymize!) }
+            elsif self.send(association)
+              self.send(association).send(:anonymize!)
+            end
+          end
+        end
+
+        def _delete_associations
+          self.class.anonymization_config.associations_to_delete.each do |association|
+            if self.send(association).respond_to?(:each)
+              self.send(association).each {|r| r.delete}
+            elsif self.send(association)
+              self.send(association).delete
+            end
+          end
+        end
+
+        def _destroy_associations
+          self.class.anonymization_config.associations_to_destroy.each do |association|
+            if self.send(association).respond_to?(:each)
+              self.send(association).each {|r| r.destroy}
+            elsif self.send(association)
+              self.send(association).destroy
+            end
+          end
+        end
+
+        def _perform_post_anonymization_callbacks(original_attributes)
+          self.class.anonymization_config.post_anonymization_callbacks.each do |callback|
+            if callback.respond_to?(:call)
+              callback.call(original_attributes)
+            else
+              self.send(callback, original_attributes)
+            end
+          end
+        end
+
+    end
+
+  end
+
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Base.send(:extend, Anonymizable)
+end

data/lib/anonymizable/configuration.rb

@@ -0,0 +1,100 @@
+require 'set'
+
+module Anonymizable
+  class ConfigurationError < ArgumentError; end
+
+  class Configuration
+
+    attr_reader :guard,
+                :attrs_to_nullify,
+                :attrs_to_anonymize,
+                :associations_to_anonymize,
+                :associations_to_delete,
+                :associations_to_destroy,
+                :post_anonymization_callbacks
+
+    def initialize(klass)
+      @klass                        = klass
+      @guard                        = nil
+      @attrs_to_nullify             = Set.new
+      @attrs_to_anonymize           = Hash.new
+      @associations_to_anonymize    = Set.new
+      @associations_to_delete       = Set.new
+      @associations_to_destroy      = Set.new
+      @post_anonymization_callbacks = Set.new
+      @public                       = false
+      @raise_on_delete          = false
+    end
+
+    def only_if(callback)
+      validate_callback(callback)
+
+      @guard = callback
+    end
+
+    def attributes(*attrs)
+      @attrs_to_anonymize.merge! attrs.extract_options!
+
+      attrs.each do |attr|
+          validate_attribute(attr)
+        end
+
+      @attrs_to_nullify += attrs
+    end
+
+    def associations(*associations, &block)
+      instance_eval(&block)
+    end
+
+    def after(*callbacks)
+      callbacks.each do |callback|
+        validate_callback(callback)
+      end
+
+      @post_anonymization_callbacks += callbacks
+    end
+
+    def public?
+      @public
+    end
+
+    def raise_on_delete?
+      @raise_on_delete
+    end
+
+    private
+
+      def public
+        @public = true
+      end
+
+      def raise_on_delete
+        @raise_on_delete = true
+      end
+
+      def anonymize(*associations)
+        @associations_to_anonymize += associations
+      end
+
+      def delete(*associations)
+        @associations_to_delete += associations
+      end
+
+      def destroy(*associations)
+        @associations_to_destroy += associations
+      end
+
+      def validate_callback(callback)
+        if !callback.respond_to?(:call) && !callback.is_a?(String) && !callback.is_a?(Symbol)
+          raise ConfigurationError.new("Expected #{callback} to respond to 'call' or be a string or symbol.")
+        end
+      end
+
+      def validate_attribute(attr)
+        if !@klass.attribute_names.include?(attr.to_s)
+          raise ConfigurationError.new("Nonexitent attribute #{attr} on #{@klass}.")
+        end
+      end
+
+  end
+end

data/lib/anonymizable/version.rb

@@ -0,0 +1,3 @@
+module Anonymizable
+  VERSION = "0.1"
+end

data/spec/anonymizable_spec.rb

@@ -0,0 +1,200 @@
+require 'spec_helper'
+
+describe Anonymizable do
+
+  describe "anonymizable" do
+
+    it "should define a private instance method named anonymize!" do
+      expect(Post.private_instance_methods(false)).to include(:anonymize!)
+      expect(Comment.private_instance_methods(false)).to include(:anonymize!)
+      expect(Like.private_instance_methods(false)).to include(:anonymize!)
+    end
+
+    it "should make anonymize! public if specified" do
+      expect(User.public_instance_methods(false)).to include(:anonymize!)
+    end
+
+    it "should raise an error if delete is called on the model when raise_on_delete option is set" do
+      user = FactoryGirl.create(:user)
+
+      expect { user.delete }.to raise_error(Anonymizable::DeleteProhibitedError, "delete is prohibited on User")
+    end
+
+    it "should raise an error if destroy is called on the model when raise_on_delete options is set" do
+      user = FactoryGirl.create(:user)
+
+      expect { user.destroy }.to raise_error(Anonymizable::DestroyProhibitedError, "destroy is prohibited on User")
+    end
+
+  end
+
+  describe "anonymize!" do
+
+    it "should be short-circuited by guard" do
+      admin = FactoryGirl.create(:admin)
+
+      expect(admin.anonymize!).to eq(false)
+    end
+
+    it "should nullify all attributes named" do
+      user = FactoryGirl.create(:user, first_name: "Joe", last_name: "user", profile: "I am a user")
+
+      expect(user.anonymize!).to eq(true)
+
+      user.reload
+
+      expect(user.first_name).to be_nil
+      expect(user.last_name).to be_nil
+      expect(user.profile).to be_nil
+    end
+
+    it "should roll back the transaction if anonymization fails" do
+      class Admin < User
+        anonymizable public: true do
+          attributes :role_id
+        end
+      end
+
+      user = Admin.create!  first_name: "Admin", 
+                            last_name: "User", 
+                            profile: "I am an admin. Kinda.",
+                            email: "admin@anonymizable.io",
+                            role: FactoryGirl.create(:role),
+                            password: "foobar"
+
+
+      expect { user.anonymize! }.to raise_error(ActiveRecord::StatementInvalid)
+
+      user.reload
+
+      expect(user.first_name).to eq("Admin")
+      expect(user.last_name).to eq("User")
+      expect(user.profile).to eq("I am an admin. Kinda.")
+      expect(user.email).to eq("admin@anonymizable.io")
+      expect(user.role.user?).to eq(true)
+      expect(user.password).to eq("foobar")
+    end
+
+    it "should anonymize attributes by proc" do
+      user = FactoryGirl.create(:user)
+      user.anonymize!
+
+      expect(user.reload.email).to eq("anonymized.user.#{user.id}@foobar.com")
+    end
+
+    it "should anonymize by method call" do
+      user = FactoryGirl.create(:user)
+      password = user.password
+      expect(user).to receive(:random_password).and_call_original
+
+      user.anonymize!
+
+      expect(user.reload.password == password).to eq(false)
+    end
+
+    it "should call anonymize! on specified associations" do
+      user = FactoryGirl.create(:user)
+      post = FactoryGirl.create(:post, user: user)
+      comment = FactoryGirl.create(:comment, post: post, user: user)
+
+      user.anonymize!
+
+      post.reload
+      comment.reload
+
+      expect(post.user_id).to be_nil
+      expect(comment.user_id).to be_nil
+    end
+
+    it "should destroy specified associations" do
+      user = FactoryGirl.create(:user)
+      3.times { FactoryGirl.create(:image, user: user) }
+
+      user.anonymize!
+      
+      expect(user.images(true).count).to eq(0)      
+    end
+
+    it "should delete specified associations" do
+      avatar = FactoryGirl.create(:avatar)
+      user = avatar.user
+      2.times { FactoryGirl.create(:like, user: user) }
+
+      user.anonymize!
+
+      expect(user.avatar(true)).to be_nil
+      expect(user.likes(true).count).to eq(0)
+    end
+
+    it "should fail if the specified association is not defined on the model" do
+      class Customer < User
+        anonymizable public: true do
+          associations do
+            anonymize :shopping_cart
+          end
+        end
+      end
+
+      user = Customer.create! email: "customer@anonymizable.io", password: "foobar",
+                              role: FactoryGirl.create(:role)
+
+      expect { user.anonymize! }.to raise_error(NoMethodError)
+    end
+
+    it "should fail if after callback is not defined" do
+      class Person < User
+        anonymizable public: true do
+          after :foo
+        end
+      end
+
+      user = Person.create! email: "person@anonymizable.io", password: "foobar",
+                            role: FactoryGirl.create(:role)
+
+      expect { user.anonymize! }.to raise_error(NoMethodError)
+    end
+
+    it "should fail if after callback method doesn't receive the correct number of arguments" do
+      class Person < User
+        anonymizable public: true do
+          after :foo
+        end
+
+        def foo
+        end
+      end
+
+      user = Person.create! email: "person@anonymizable.io", password: "foobar",
+                            role: FactoryGirl.create(:role)
+
+      expect { user.anonymize! }.to raise_error(ArgumentError)
+    end
+
+    it "should not rollback the transaction if a failure occurs in an after callback" do
+      class Employee < User
+        anonymizable public: true do
+          attributes  :first_name, :last_name, :profile,
+                      email: Proc.new {|c| "anonymized.user.#{c.id}@anonymizable.io" }, 
+                      password: :random_password
+
+          after Proc.new { raise "failure!" }
+        end
+      end
+
+      user = Employee.create! first_name: "John", last_name: "Doe", profile: "Hello world",
+                              email: "employee@anonymizable.io", password: "foobar",
+                              role: FactoryGirl.create(:role)
+
+      expect { user.anonymize! }.to raise_error(RuntimeError, "failure!")
+
+      user.reload
+
+      expect(user.first_name).to be_nil
+      expect(user.last_name).to be_nil
+      expect(user.profile).to be_nil
+      expect(user.email).to eq("anonymized.user.#{user.id}@anonymizable.io")
+      expect(user.password != "foobar").to eq(true)
+    end
+  end
+
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Anonymizable::Configuration do
+
+  let(:config) { User.anonymization_config }
+
+  describe "only_if" do
+
+    it "can receive the name of the method to guard against anonymization" do
+      expect(config.guard).to eq :can_anonymize?
+    end
+
+    it "should set the proc to guard against anonymization" do
+      proc = Proc.new { true }
+
+      config.only_if proc
+
+      expect(config.guard).to eq proc
+    end
+
+    it "should fail if not passed a Proc, String, or Symbol" do
+      expect { config.only_if true }.to raise_error(Anonymizable::ConfigurationError, "Expected true to respond to 'call' or be a string or symbol.")
+    end
+
+  end
+
+  describe "attributes" do
+
+    it "should set database columns to nullify" do
+      expect(config.attrs_to_nullify).to contain_exactly :first_name, :last_name, :profile
+    end
+
+    it "should fail if any attribute passed is not defined in the model" do
+      expect { config.attributes :middle_name }.to raise_error(Anonymizable::ConfigurationError, "Nonexitent attribute middle_name on User.")
+    end
+
+    it "should set proc by which to anonymize model attribute" do
+      expect(config.attrs_to_anonymize[:email]).to be_a Proc
+    end
+
+    it "should set name of method by which to anonymize model attribute" do
+      expect(config.attrs_to_anonymize[:password]).to eq :random_password
+    end
+
+  end
+
+  describe "associations" do
+
+    describe "anonymize" do
+      it "should set names of associations to anonymize" do
+        expect(config.associations_to_anonymize).to contain_exactly :posts, :comments
+      end
+    end
+
+    describe "delete" do
+      it "should set names of associations to delete" do
+        expect(config.associations_to_delete).to contain_exactly :avatar, :likes
+      end
+    end
+
+    describe "destroy" do
+      it "should set names of associations to destroy" do
+        expect(config.associations_to_destroy).to contain_exactly :images
+      end
+    end    
+
+  end
+
+  describe "after" do
+
+    it "should set name of methods to invoke after anonymization" do
+      expect(config.post_anonymization_callbacks.to_a).to eq [:email_user, :email_admin]
+    end
+
+    it "should set proc to call after anonymization" do
+      proc = Proc.new { "hello" }
+
+      config.after proc
+
+      expect(config.post_anonymization_callbacks.to_a).to eq [:email_user, :email_admin, proc]
+    end
+
+  end
+
+  describe "public" do
+
+    it "should set the public flag" do
+      expect(config.public?).to eq true
+    end
+
+  end
+
+  describe "raise_on_delete" do
+
+    it "should set the raise_on_delete flag" do
+      expect(config.raise_on_delete?).to eq true
+    end
+
+  end
+
+end

data/spec/database.yml

@@ -0,0 +1,3 @@
+sqlite3:
+  adapter: sqlite3
+  database: spec/anonymize.sqlite3.db

data/spec/factories/comment_factory.rb

@@ -0,0 +1,6 @@
+FactoryGirl.define do
+  factory :comment do
+    post
+    text "comment"
+  end
+end

data/spec/factories/image_factory.rb

@@ -0,0 +1,13 @@
+FactoryGirl.define do
+  factory :image do
+    user
+  end
+
+  factory :avatar do
+    user
+  end
+
+  factory :thumbnail, class: Image do
+    image
+  end
+end

data/spec/factories/like_factory.rb

@@ -0,0 +1,6 @@
+FactoryGirl.define do
+  factory :like do
+    user
+    post
+  end
+end

data/spec/factories/post_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :post do
+    title "title"
+    summary "summary"
+    content "content"
+  end
+end

data/spec/factories/role_factory.rb

@@ -0,0 +1,9 @@
+FactoryGirl.define do
+  factory :role, class: Role do
+    name "user"
+  end
+
+  factory :admin_role, class: Role do
+    name "admin"
+  end
+end

data/spec/factories/user_factory.rb

@@ -0,0 +1,13 @@
+FactoryGirl.define do
+  factory :user do
+    email { "user.#{id}@anonymizable.io" }
+    password { random_password }
+    role
+  end
+
+  factory :admin, class: User do
+    email { "admin.user.#{id}@anonymizable.io" }
+    password { random_password }
+    role { FactoryGirl.create(:admin_role) }
+  end
+end

data/spec/models/avatar.rb

@@ -0,0 +1,6 @@
+class Avatar < ActiveRecord::Base
+  self.table_name = :images
+
+  belongs_to :user, foreign_key: :profile_id
+
+end

data/spec/models/comment.rb

@@ -0,0 +1,8 @@
+class Comment < ActiveRecord::Base
+
+  belongs_to :post
+  belongs_to :user
+
+  anonymizable :user_id
+
+end

data/spec/models/image.rb

@@ -0,0 +1,6 @@
+class Image < ActiveRecord::Base
+
+  belongs_to :user
+  has_many :thumbnails, class_name: "Image"
+
+end

data/spec/models/like.rb

@@ -0,0 +1,8 @@
+class Like < ActiveRecord::Base
+
+  belongs_to :user
+  belongs_to :post
+
+  anonymizable :user_id
+
+end

data/spec/models/post.rb

@@ -0,0 +1,10 @@
+class Post < ActiveRecord::Base
+
+  belongs_to :user
+  has_many :comments
+  has_many :images
+  has_many :likes
+
+  anonymizable :user_id
+
+end

data/spec/models/role.rb

@@ -0,0 +1,11 @@
+class Role < ActiveRecord::Base
+
+  has_many :users
+
+  def method_missing(method_name, *args, &block)
+    if /[a-z]+\?/.match(method_name)
+      return name == method_name.to_s.sub(/\?/,"")
+    end
+  end
+
+end

data/spec/models/user.rb

@@ -0,0 +1,40 @@
+class User < ActiveRecord::Base
+
+  anonymizable public: true, raise_on_delete: true do
+    only_if :can_anonymize?
+
+    attributes  :first_name, :last_name, :profile,
+                email: Proc.new {|u| "anonymized.user.#{u.id}@foobar.com" }, 
+                password: :random_password
+
+    associations do
+      anonymize :posts, :comments
+      delete    :avatar, :likes
+      destroy   :images
+    end
+
+    after :email_user, :email_admin
+  end
+
+  belongs_to  :role
+  has_many    :posts
+  has_many    :comments
+  has_one     :avatar, foreign_key: :profile_id
+  has_many    :images
+  has_many    :likes
+
+  def can_anonymize?
+    !role.admin?
+  end
+
+  def random_password
+    SecureRandom.hex.sub(/([a-z])/) {|s| s.upcase}
+  end
+
+  def email_user(original_attributes)
+  end
+
+  def email_admin(original_attributes)
+  end
+
+end

data/spec/schema.rb

@@ -0,0 +1,50 @@
+ActiveRecord::Schema.define(version: 0) do
+
+  create_table :users, force: true do |t|
+    t.string  :first_name
+    t.string  :last_name
+    t.string  :email,     null: false
+    t.string  :password,  null: false
+    t.integer :role_id,   null: false
+    t.string  :profile
+    t.timestamps          null: false
+  end
+
+  create_table :roles, force: true do |t|
+    t.string :name, null: false
+    t.timestamps    null: false
+  end
+
+  create_table :posts, force: true do |t|
+    t.integer :user_id
+    t.string  :title,   null: false
+    t.string  :summary, null: false
+    t.text    :content, null: false
+    t.timestamps        null: false
+  end
+
+  create_table :comments, force: true do |t|
+    t.integer :user_id
+    t.integer :post_id, null: false
+    t.text    :text,    null: false
+    t.timestamps        null: false
+  end
+
+  create_table :likes, force: true do |t|
+    t.integer :user_id
+    t.integer :post_id, null: false
+    t.timestamps        null: false
+  end
+
+  create_table :images, force: true do |t|
+    t.integer :image_id
+    t.integer :user_id
+    t.integer :profile_id
+    t.integer :width
+    t.integer :height
+    t.binary  :data
+    t.string  :caption
+    t.timestamps  null: false
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'models')))
+
+require 'anonymizable'
+require 'logger'
+require 'rspec'
+require 'database_cleaner'
+require 'factory_girl'
+require 'yaml'
+
+def load_schema
+  config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+  ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+  ActiveRecord::Base.establish_connection(config['sqlite3'])
+  load(File.dirname(__FILE__) + "/schema.rb")
+end
+
+def load_models
+  Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), 'models/*.rb'))).each {|f| require f}
+  Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), 'factories/*.rb'))).each {|f| require f}
+end
+
+load_schema
+load_models
+
+RSpec.configure do |config|
+  config.color      = true
+  config.formatter  = :documentation
+  config.include FactoryGirl::Syntax::Methods
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.after(:each) do |example|
+    DatabaseCleaner.clean
+  end
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: anonymizable
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Mike Bradford
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.5'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: Delete data without deleting it
+email:
+- mbradford@47primes.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".pryrc"
+- Gemfile
+- README.md
+- anonymizable.gemspec
+- lib/anonymizable.rb
+- lib/anonymizable/configuration.rb
+- lib/anonymizable/version.rb
+- spec/anonymizable_spec.rb
+- spec/configuration_spec.rb
+- spec/database.yml
+- spec/factories/comment_factory.rb
+- spec/factories/image_factory.rb
+- spec/factories/like_factory.rb
+- spec/factories/post_factory.rb
+- spec/factories/role_factory.rb
+- spec/factories/user_factory.rb
+- spec/models/avatar.rb
+- spec/models/comment.rb
+- spec/models/image.rb
+- spec/models/like.rb
+- spec/models/post.rb
+- spec/models/role.rb
+- spec/models/user.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+homepage: https://github.com/47primes/anonymizable
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Anonymize columns in ActiveRecord models
+test_files: []