column_anonymizer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '01355341091ad9946164e31cd2b99be788e6c0c4feeaf57e660ec626dbe90ccd'
+  data.tar.gz: faf09021710551d4b0524da501b92e2d8ab263a4a1bc0a02069683a5afe3601d
+SHA512:
+  metadata.gz: ccffa458954da6a422ae3a0d9cfe890fc9a2587d4f4df00b3bf1dc39cbfd2f322089c1ec563e5c8a2fb18d51781bcdeb8a484ee6479b6fc3ebcce245c86e1c87
+  data.tar.gz: 067fb6ee7eb334491934d792b9e7f84890bb6f81626b53bb1797850f373d3ae749ced9bf4757dd9d8ccbcb6a9f40a838c60eebe6e8b99716dfcc661de6cb9f98

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rspec_status

@@ -0,0 +1,15 @@
+example_id                                | status | run_time        |
+----------------------------------------- | ------ | --------------- |
+./spec/column_anonymizer_spec.rb[1:1]     | passed | 0.00027 seconds |
+./spec/column_anonymizer_spec.rb[1:2:1]   | passed | 0.00042 seconds |
+./spec/column_anonymizer_spec.rb[1:2:2]   | passed | 0.00003 seconds |
+./spec/column_anonymizer_spec.rb[1:2:3]   | passed | 0.00002 seconds |
+./spec/column_anonymizer_spec.rb[1:3:1]   | passed | 0.00034 seconds |
+./spec/column_anonymizer_spec.rb[1:4:1:1] | passed | 0.00099 seconds |
+./spec/column_anonymizer_spec.rb[1:4:1:2] | passed | 0.71609 seconds |
+./spec/column_anonymizer_spec.rb[1:4:1:3] | passed | 0.00079 seconds |
+./spec/column_anonymizer_spec.rb[1:4:1:4] | passed | 0.00008 seconds |
+./spec/column_anonymizer_spec.rb[1:4:1:5] | passed | 0.00013 seconds |
+./spec/column_anonymizer_spec.rb[1:4:1:6] | passed | 0.00026 seconds |
+./spec/column_anonymizer_spec.rb[1:4:2:1] | passed | 0.00003 seconds |
+./spec/column_anonymizer_spec.rb[1:4:2:2] | passed | 0.00003 seconds |

data/CHANGELOG.md

@@ -0,0 +1,49 @@
+## [Unreleased]
+
+### Added
+- **Rake Tasks for Bulk Anonymization**: Process large datasets efficiently
+  - `rake column_anonymizer:anonymize_all` - Anonymize all models
+  - `rake column_anonymizer:anonymize_model[ModelName]` - Anonymize specific model
+  - `rake column_anonymizer:anonymize_where[Model,'condition']` - Conditional anonymization
+  - `rake column_anonymizer:preview` - Dry run without changes
+  - `rake column_anonymizer:stats` - Show statistics
+  - Progress tracking for long-running operations
+  - Error handling and recovery
+  - Confirmation prompts for conditional anonymization
+- **Custom Anonymization Generators**: Register your own anonymization types
+  - `ColumnAnonymizer::Anonymizer.register(type, &block)` API
+  - Support for domain-specific data formats (credit cards, employee IDs, etc.)
+  - Flexible registration with blocks, lambdas, or callable objects
+  - New `rails generate column_anonymizer:initializer` command
+  - Comprehensive API: `register`, `unregister`, `all_generators`, `generator_exists?`
+  - Custom generators merge with built-in generators seamlessly
+- **Automatic Model Scanner**: New `rails generate column_anonymizer:scan` command
+  - Automatically discovers all models with `encrypts` calls
+  - Intelligently guesses data types based on column names (email, phone, ssn, etc.)
+  - **Append-only mode**: Preserves existing formatting, comments, and order
+  - Inserts new columns under existing models
+  - Appends new models at the end of the file
+  - Shows detailed feedback about discovered and skipped columns
+- `--scan` option for install generator: `rails generate column_anonymizer:install --scan`
+- Comprehensive type guessing for common column name patterns
+
+### Changed
+- Anonymizer now uses `BUILT_IN_GENERATORS` constant instead of `GENERATORS`
+- `all_generators` method merges built-in and custom generators dynamically
+- Scan generator now uses append-only strategy instead of regenerating entire file
+  - Preserves comments and custom formatting in YAML
+  - Git-friendly with minimal diffs
+  - Safe for team environments with organized config files
+- Updated install generator to suggest scan option
+- Enhanced README with scan generator and custom generators documentation
+
+## [0.1.0] - 2026-02-04
+
+- Initial release with YAML-based configuration
+- Add `SchemaLoader` to load encrypted column types from `config/encrypted_columns.yml`
+- Add `Encryptable` module that reads column types from YAML schema
+- Add `Anonymizer` class with built-in generators for common data types (email, phone, SSN, name, address, etc.)
+- Add `anonymize_model` and `anonymize_model!` methods for intelligent data anonymization
+- Add Rails generator for installing YAML configuration file
+- Seamless integration with Rails 7+ Active Record Encryption via Railtie
+- Support for all standard `encrypts` method options

data/CUSTOM_GENERATORS_COMPLETE.md

@@ -0,0 +1,507 @@
+# ✅ Custom Generators Implementation Complete
+
+## 🎯 Your Request
+**"I want a way to add custom anonymization types from within the rails app. I am thinking it would be some ruby class somewhere that would define a custom type then it would get appended when we anonymize the data"**
+
+## ✅ Delivered!
+
+You can now register custom anonymization types from within your Rails app using a simple, flexible API.
+
+---
+
+## 📦 What Was Created
+
+### 1. **Enhanced Anonymizer Class**
+**File**: `lib/column_anonymizer/anonymizer.rb`
+
+**New Features:**
+- `register(type, &block)` - Register custom generators
+- `unregister(type)` - Remove custom generators
+- `all_generators` - Get built-in + custom generators merged
+- `generator_exists?(type)` - Check if a generator exists
+- `reset_custom_generators!` - Clear custom generators (for testing)
+- `BUILT_IN_GENERATORS` constant (renamed from `GENERATORS`)
+- `@custom_generators` class instance variable to store custom types
+
+### 2. **Initializer Generator**
+**File**: `lib/generators/column_anonymizer/initializer/initializer_generator.rb`
+
+Command: `rails generate column_anonymizer:initializer`
+
+Creates: `config/initializers/column_anonymizer.rb` with:
+- Example custom generators
+- Helpful comments
+- Common patterns
+- List of built-in types
+
+### 3. **Initializer Template**
+**File**: `lib/generators/column_anonymizer/initializer/templates/column_anonymizer.rb`
+
+Includes examples for:
+- Simple masking (credit cards)
+- Using Faker
+- Custom business logic
+- Format-specific patterns
+- Using Rails models
+- Date/time generators
+- Complex multi-field logic
+
+### 4. **Comprehensive Documentation**
+- `CUSTOM_GENERATORS_GUIDE.md` (500+ lines) - Complete guide
+- `CUSTOM_GENERATORS_QUICK_REF.md` - Quick reference
+- Updated `README.md` - Custom generators section
+- Updated `CHANGELOG.md` - Feature documentation
+
+---
+
+## 🚀 How It Works
+
+### Step 1: Generate Initializer
+```bash
+rails generate column_anonymizer:initializer
+```
+
+### Step 2: Register Custom Types
+```ruby
+# config/initializers/column_anonymizer.rb
+
+ColumnAnonymizer::Anonymizer.register(:credit_card) do
+  "XXXX-XXXX-XXXX-#{rand(1000..9999)}"
+end
+
+ColumnAnonymizer::Anonymizer.register(:employee_id) do
+  "EMP-#{Time.now.year}-#{rand(10000..99999)}"
+end
+```
+
+### Step 3: Use in YAML Config
+```yaml
+# config/encrypted_columns.yml
+User:
+  credit_card_number: credit_card  # ← Custom type!
+  employee_number: employee_id     # ← Custom type!
+```
+
+### Step 4: Anonymize
+```ruby
+user = User.first
+ColumnAnonymizer::Anonymizer.anonymize_model!(user)
+
+# credit_card_number => "XXXX-XXXX-XXXX-4823"
+# employee_number => "EMP-2026-47293"
+```
+
+---
+
+## 🎨 Registration Patterns
+
+### Block Syntax (Recommended)
+```ruby
+ColumnAnonymizer::Anonymizer.register(:custom_type) do
+  "VALUE-#{SecureRandom.hex(4)}"
+end
+```
+
+### Lambda Syntax
+```ruby
+ColumnAnonymizer::Anonymizer.register(:uuid, -> { SecureRandom.uuid })
+```
+
+### Callable Object
+```ruby
+class EmployeeIdGenerator
+  def self.call
+    "EMP-#{Time.now.year}-#{rand(10000..99999)}"
+  end
+end
+
+ColumnAnonymizer::Anonymizer.register(:employee_id, EmployeeIdGenerator)
+```
+
+---
+
+## 📋 Example Custom Generators
+
+### Credit Card Masking
+```ruby
+ColumnAnonymizer::Anonymizer.register(:credit_card) do
+  "XXXX-XXXX-XXXX-#{rand(1000..9999)}"
+end
+```
+
+### License Plate
+```ruby
+ColumnAnonymizer::Anonymizer.register(:license_plate) do
+  letters = ('A'..'Z').to_a.sample(3).join
+  numbers = rand(100..999)
+  "#{letters}-#{numbers}"
+end
+```
+
+### Account Number with Format
+```ruby
+ColumnAnonymizer::Anonymizer.register(:account_number) do
+  prefix = "ACC"
+  year = Time.now.year
+  sequence = rand(10000..99999)
+  "#{prefix}#{year}#{sequence}"
+end
+```
+
+### Using Faker
+```ruby
+ColumnAnonymizer::Anonymizer.register(:company_name) do
+  Faker::Company.name
+end
+```
+
+### From Database
+```ruby
+ColumnAnonymizer::Anonymizer.register(:department_name) do
+  Department.active.pluck(:name).sample || "General"
+end
+```
+
+---
+
+## 🔧 API Reference
+
+### Register a Generator
+```ruby
+ColumnAnonymizer::Anonymizer.register(type, generator = nil, &block)
+
+# With block
+register(:type) { "value" }
+
+# With lambda
+register(:type, -> { "value" })
+
+# With callable
+register(:type, MyGenerator)
+```
+
+### Unregister a Generator
+```ruby
+ColumnAnonymizer::Anonymizer.unregister(:type)
+```
+
+### Check if Generator Exists
+```ruby
+ColumnAnonymizer::Anonymizer.generator_exists?(:type)
+# => true/false
+```
+
+### Get All Generators
+```ruby
+ColumnAnonymizer::Anonymizer.all_generators
+# => { email: #<Proc>, phone: #<Proc>, credit_card: #<Proc>, ... }
+```
+
+### Reset Custom Generators (Testing)
+```ruby
+ColumnAnonymizer::Anonymizer.reset_custom_generators!
+```
+
+---
+
+## 🧪 How Custom Generators Merge
+
+### Built-in Generators
+```ruby
+BUILT_IN_GENERATORS = {
+  email: -> { Faker::Internet.email },
+  phone: -> { Faker::PhoneNumber.phone_number },
+  ssn: -> { Faker::IdNumber.ssn_valid },
+  name: -> { Faker::Name.name },
+  first_name: -> { Faker::Name.first_name },
+  last_name: -> { Faker::Name.last_name },
+  address: -> { Faker::Address.full_address },
+  text: -> { Faker::Lorem.paragraph }
+}
+```
+
+### Custom Generators
+```ruby
+@custom_generators = {
+  credit_card: -> { "XXXX-XXXX-XXXX-#{rand(1000..9999)}" },
+  employee_id: -> { "EMP-#{Time.now.year}-#{rand(10000..99999)}" }
+}
+```
+
+### Merged (all_generators)
+```ruby
+{
+  # Built-ins
+  email: -> { ... },
+  phone: -> { ... },
+  ssn: -> { ... },
+  name: -> { ... },
+  first_name: -> { ... },
+  last_name: -> { ... },
+  address: -> { ... },
+  text: -> { ... },
+  
+  # Custom
+  credit_card: -> { ... },
+  employee_id: -> { ... }
+}
+```
+
+---
+
+## 🔄 Complete Workflow
+
+### 1. Setup
+```bash
+# Install gem
+echo "gem 'column_anonymizer'" >> Gemfile
+bundle install
+
+# Generate config
+rails g column_anonymizer:install --scan
+
+# Generate initializer for custom types
+rails g column_anonymizer:initializer
+```
+
+### 2. Define Custom Types
+```ruby
+# config/initializers/column_anonymizer.rb
+
+ColumnAnonymizer::Anonymizer.register(:credit_card) do
+  "XXXX-XXXX-XXXX-#{rand(1000..9999)}"
+end
+
+ColumnAnonymizer::Anonymizer.register(:employee_id) do
+  "EMP-#{Time.now.year}-#{rand(10000..99999)}"
+end
+
+ColumnAnonymizer::Anonymizer.register(:medical_record) do
+  "MRN#{rand(100000..999999)}"
+end
+```
+
+### 3. Configure YAML
+```yaml
+# config/encrypted_columns.yml
+User:
+  email: email                    # Built-in
+  credit_card_number: credit_card # Custom!
+
+Employee:
+  employee_number: employee_id    # Custom!
+  ssn: ssn                        # Built-in
+
+Patient:
+  medical_record_number: medical_record  # Custom!
+```
+
+### 4. Use in Models
+```ruby
+class User < ApplicationRecord
+  encrypts :email
+  encrypts :credit_card_number
+end
+
+class Employee < ApplicationRecord
+  encrypts :employee_number
+  encrypts :ssn
+end
+
+class Patient < ApplicationRecord
+  encrypts :medical_record_number
+end
+```
+
+### 5. Anonymize
+```ruby
+user = User.first
+ColumnAnonymizer::Anonymizer.anonymize_model!(user)
+
+# Before:
+# email: "john@example.com"
+# credit_card_number: "4532-1234-5678-9012"
+
+# After:
+# email: "user_abc123@example.com"
+# credit_card_number: "XXXX-XXXX-XXXX-7482"
+```
+
+---
+
+## ✨ Benefits
+
+### Flexibility
+- ✅ Define any custom format
+- ✅ Use Faker, Rails models, or custom logic
+- ✅ Domain-specific anonymization
+
+### Simplicity
+- ✅ Easy registration with blocks
+- ✅ No complex class hierarchy
+- ✅ Just define and use
+
+### Power
+- ✅ Access to full Ruby/Rails environment
+- ✅ Can use database queries
+- ✅ Can use external libraries
+
+### Maintainability
+- ✅ All custom types in one place (initializer)
+- ✅ Easy to test
+- ✅ Clear separation from built-ins
+
+---
+
+## 🧪 Testing
+
+```ruby
+# spec/initializers/column_anonymizer_spec.rb
+
+RSpec.describe "Custom Anonymizers" do
+  before do
+    ColumnAnonymizer::Anonymizer.reset_custom_generators!
+    
+    ColumnAnonymizer::Anonymizer.register(:credit_card) do
+      "XXXX-XXXX-XXXX-#{rand(1000..9999)}"
+    end
+  end
+
+  it "registers custom generator" do
+    expect(ColumnAnonymizer::Anonymizer.generator_exists?(:credit_card)).to be true
+  end
+
+  it "generates correct format" do
+    generator = ColumnAnonymizer::Anonymizer.all_generators[:credit_card]
+    result = generator.call
+    
+    expect(result).to match(/^XXXX-XXXX-XXXX-\d{4}$/)
+  end
+
+  it "merges with built-in generators" do
+    generators = ColumnAnonymizer::Anonymizer.all_generators
+    
+    expect(generators).to include(:email, :phone, :credit_card)
+  end
+end
+```
+
+---
+
+## 📊 Technical Implementation
+
+### Class Structure
+```ruby
+class Anonymizer
+  # Built-in generators (frozen)
+  BUILT_IN_GENERATORS = { ... }.freeze
+  
+  # Custom generators (mutable)
+  @custom_generators = {}
+  
+  class << self
+    # Registration API
+    def register(type, generator = nil, &block)
+      # Store in @custom_generators
+    end
+    
+    # Merge built-in + custom
+    def all_generators
+      BUILT_IN_GENERATORS.merge(@custom_generators)
+    end
+    
+    # Use merged generators
+    def anonymize_model(model_instance)
+      generators = all_generators
+      # Use generators[column_type]
+    end
+  end
+end
+```
+
+### Flow
+```
+1. Rails boots
+2. Initializer loads (config/initializers/column_anonymizer.rb)
+3. Custom generators registered via .register()
+4. Stored in @custom_generators
+5. When anonymizing:
+   - all_generators called
+   - BUILT_IN_GENERATORS.merge(@custom_generators)
+   - Merged hash used for anonymization
+6. Custom types override built-ins if same key
+```
+
+---
+
+## 📚 Documentation
+
+### Created
+1. **CUSTOM_GENERATORS_GUIDE.md** (500+ lines)
+   - Complete guide with examples
+   - All registration patterns
+   - Advanced use cases
+   - Best practices
+   - Troubleshooting
+
+2. **CUSTOM_GENERATORS_QUICK_REF.md**
+   - One-page reference
+   - Common patterns
+   - API methods
+   - Quick examples
+
+3. **README.md** - Updated
+   - Custom generators section
+   - Quick example
+   - Link to full guide
+
+4. **CHANGELOG.md** - Updated
+   - Feature documented
+   - API listed
+   - Changes noted
+
+---
+
+## 🎉 Summary
+
+You can now add custom anonymization types easily:
+
+### Command
+```bash
+rails generate column_anonymizer:initializer
+```
+
+### Register
+```ruby
+ColumnAnonymizer::Anonymizer.register(:custom_type) do
+  # Your anonymization logic
+end
+```
+
+### Use
+```yaml
+Model:
+  column: custom_type
+```
+
+**Simple, powerful, and flexible!** 🚀
+
+---
+
+## 📦 Files Summary
+
+| File | Purpose |
+|------|---------|
+| `lib/column_anonymizer/anonymizer.rb` | Enhanced with registration API |
+| `lib/generators/.../initializer_generator.rb` | Generator command |
+| `lib/generators/.../templates/column_anonymizer.rb` | Template with examples |
+| `CUSTOM_GENERATORS_GUIDE.md` | Complete documentation |
+| `CUSTOM_GENERATORS_QUICK_REF.md` | Quick reference |
+| `README.md` | Updated with custom generators |
+| `CHANGELOG.md` | Feature documented |
+
+---
+
+**Status:** ✅ **COMPLETE AND READY TO USE**  
+**Date:** February 5, 2026  
+**Implementation:** Custom generator registration system