purrrge 1.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c7b2333776af99cfacf97761bf7dbfd6207abd7b06f2a20320ac81ec4e2c29e3
+  data.tar.gz: 6094f74be0f2e172c525e9470cb8aba63e22d1f2e758e6f372d606e299379986
+SHA512:
+  metadata.gz: 1f457fbe59ee707dbf2fc7c65bdb3934fd8643fd8c00d89e79ef44440b6de2b9091e9e7dfdbe576a14ccb830511e4f66440ef8666043c27f56e959dafb67410b
+  data.tar.gz: 42ee9fa831fad3da6b91f897d73d3fc5f7198af2f8df70e5bfc952c1f9651565acbd077bd2c1cd4fcaadd4e4eba0c37aedd0325d8f968dcdf6cd587b27b0d60b

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,36 @@
+AllCops:
+  TargetRubyVersion: 2.6
+  NewCops: enable
+  Exclude:
+    - 'vendor/**/*'
+    - 'bin/**/*'
+    - 'spec/spec_helper.rb'
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+    - '*.gemspec'
+
+Metrics/MethodLength:
+  Max: 20
+
+Style/Documentation:
+  Enabled: true
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+
+Style/ClassAndModuleChildren:
+  Enabled: false 

data/.semaphore/semaphore.yml

@@ -0,0 +1,52 @@
+version: v1.0
+name: Purrrge
+agent:
+  machine:
+    type: e1-standard-2
+    os_image: ubuntu2004
+
+auto_cancel:
+  running:
+    when: "branch != 'main'"
+
+global_job_config:
+  prologue:
+    commands:
+      - checkout
+      - sem-version ruby 3.2
+      - bundle config set --local path 'vendor/bundle'
+      - bundle install
+
+blocks:
+  - name: "Test"
+    dependencies: []
+    task:
+      jobs:
+        - name: "RSpec"
+          commands:
+            - bundle exec rspec
+        
+  - name: "Build"
+    dependencies: ["Test"]
+    task:
+      jobs:
+        - name: "Build Gem"
+          commands:
+            - gem build purrrge.gemspec
+            - "test -f purrrge-*.gem"
+
+  - name: "Lint"
+    dependencies: []
+    task:
+      jobs:
+        - name: "Ruby Lint"
+          commands:
+            - gem install rubocop
+            - rubocop --version
+            - rubocop
+
+promotions:
+  - name: Version & Tag
+    pipeline_file: version-and-tag.yml
+    auto_promote:
+      when: "result = 'passed' and branch = 'main'" 

data/.semaphore/version-and-tag.yml

@@ -0,0 +1,46 @@
+version: v1.0
+name: Version and Tag
+agent:
+  machine:
+    type: e1-standard-2
+    os_image: ubuntu2004
+
+global_job_config:
+  prologue:
+    commands:
+      - checkout
+      - sem-version ruby 3.2
+      - bundle config set --local path 'vendor/bundle'
+      - bundle install
+
+blocks:
+  - name: "Version & Tag"
+    task:
+      secrets:
+        - name: purrrge-github-token
+      jobs:
+        - name: "Bump Version & Push Tag"
+          commands:
+            - git config --global user.email "ci@semaphore.com"
+            - git config --global user.name "Semaphore CI"
+            - 'ruby -e ''require "./lib/purrrge/version"; puts "CURRENT_VERSION=#{Purrrge::VERSION}"'' > version.env'
+            - source version.env
+            - 'echo "Current version: $CURRENT_VERSION"'
+            - 'IFS="." read -r MAJOR MINOR PATCH <<< "$CURRENT_VERSION"'
+            - 'echo "Parsed version: $MAJOR.$MINOR.$PATCH"'
+            - 'LAST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "none")'
+            - 'if [ "$LAST_TAG" = "none" ]; then COMMITS=$(git log --pretty=format:"%s" --no-merges); else COMMITS=$(git log $LAST_TAG..HEAD --pretty=format:"%s" --no-merges); fi'
+            - 'BUMP_TYPE="patch"'
+            - 'if echo "$COMMITS" | grep -qE "BREAKING CHANGE|MAJOR"; then BUMP_TYPE="major"; elif echo "$COMMITS" | grep -qE "feat:|feature:|MINOR"; then BUMP_TYPE="minor"; fi'
+            - 'echo "Bump type: $BUMP_TYPE"'
+            - 'if [ "$BUMP_TYPE" = "major" ]; then NEW_MAJOR=$((MAJOR + 1)); NEW_MINOR=0; NEW_PATCH=0; elif [ "$BUMP_TYPE" = "minor" ]; then NEW_MAJOR=$MAJOR; NEW_MINOR=$((MINOR + 1)); NEW_PATCH=0; else NEW_MAJOR=$MAJOR; NEW_MINOR=$MINOR; NEW_PATCH=$((PATCH + 1)); fi'
+            - 'NEW_VERSION="$NEW_MAJOR.$NEW_MINOR.$NEW_PATCH"'
+            - 'echo "New version: $NEW_VERSION"'
+            - 'sed -i "s/VERSION = \"$CURRENT_VERSION\"/VERSION = \"$NEW_VERSION\"/" lib/purrrge/version.rb'
+            - git add lib/purrrge/version.rb
+            - 'git commit -m "Bump version to $NEW_VERSION [skip ci]"'
+            - 'git tag -a "v$NEW_VERSION" -m "Version $NEW_VERSION"'
+            # Use GITHUB_TOKEN for Git operations
+            - 'git remote set-url origin https://x-access-token:${PURRRGE_GITHUB_TOKEN}@github.com/Grayscale-Labs/purrrge.git'
+            - git push origin main
+            - 'git push origin "v$NEW_VERSION"' 

data/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.1.0] - 2025-03-11
+
+### Added
+- Added callback support with `before_scrub` and `after_scrub` methods
+- Added support for running callbacks around the scrubbing process
+
+## [1.0.0] - 2025-03-10
+
+### Added
+- Initial stable release
+- Core functionality for marking fields as scrubbable
+- Support for custom scrubbing methods
+- Support for setting specific scrub values
+
+## [0.1.1] - 2025-03-07
+
+### Added
+- Initial gem functionality
+- Basic scrubbing support 

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in purrrge.gemspec
+gemspec
+
+# Development dependencies
+group :development, :test do
+  gem "rspec", "~> 3.0"
+  gem "rubocop", "~> 1.74"
+end
+
+gem "rake", "~> 13.0"

data/Gemfile.lock

@@ -0,0 +1,93 @@
+PATH
+  remote: .
+  specs:
+    purrrge (1.5.0)
+      activesupport (>= 5.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (8.0.1)
+      base64
+      benchmark (>= 0.3)
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      logger (>= 1.4.2)
+      minitest (>= 5.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    ast (2.4.3)
+    base64 (0.2.0)
+    benchmark (0.4.0)
+    bigdecimal (3.1.9)
+    concurrent-ruby (1.3.5)
+    connection_pool (2.5.0)
+    diff-lcs (1.6.0)
+    drb (2.2.1)
+    i18n (1.14.7)
+      concurrent-ruby (~> 1.0)
+    json (2.18.0)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    logger (1.6.6)
+    minitest (5.25.4)
+    parallel (1.27.0)
+    parser (3.3.10.1)
+      ast (~> 2.4.1)
+      racc
+    prism (1.8.0)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    rake (13.2.1)
+    regexp_parser (2.11.3)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.3)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.2)
+    rubocop (1.84.0)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.49.0)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    ruby-progressbar (1.13.0)
+    securerandom (0.4.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.2.0)
+    uri (1.0.3)
+
+PLATFORMS
+  arm64-darwin-24
+
+DEPENDENCIES
+  purrrge!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rubocop (~> 1.74)
+
+BUNDLED WITH
+   2.4.10

data/README.md

@@ -0,0 +1,340 @@
+# Purrrge
+
+Purrrge is a data retention and scrubbing library for Ruby applications. It provides tools for implementing data retention policies and scrubbing sensitive data in compliance with privacy regulations.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'purrrge'
+```
+
+And then execute:
+
+```
+$ bundle install
+```
+
+Or install it yourself as:
+
+```
+$ gem install purrrge
+```
+
+## Usage
+
+### Scrubbable Concern
+
+The `Scrubbable` concern allows you to define fields in your models that should be scrubbed (anonymized or removed) when data retention periods expire. This makes it easy to implement data retention policies across your application.
+
+#### Basic Usage
+
+```ruby
+class User
+  include Purrrge::Scrubbable
+  
+  # Define fields to be scrubbed and how they should be scrubbed
+  scrub_field :email, scrub_value: nil                   # Set to nil
+  scrub_field :name, scrub_value: "REDACTED"             # Replace with static text
+  scrub_field :phone, scrub_method: :anonymize_phone     # Use custom method
+  
+  # Define custom scrubbing method
+  def anonymize_phone(field)
+    self[field] = "xxx-xxx-xxxx"
+  end
+end
+```
+
+#### Implementing Scrubbing Logic
+
+You can scrub individual records by calling `scrub!` on them:
+
+```ruby
+user = User.find(123)
+user.scrub!  # Apply scrubbing to this user
+```
+
+For scrubbing based on retention policies, you might implement a background job:
+
+```ruby
+class DataRetentionWorker
+  include Sidekiq::Worker
+  
+  def perform
+    Organization.where.not(data_retention_period: nil).find_each do |org|
+      cutoff_date = org.data_retention_period.days.ago
+      
+      # Find users to be scrubbed for this organization
+      User.where(organization_id: org.id)
+          .where('created_at < ?', cutoff_date)
+          .find_each do |user|
+        user.scrub!
+      end
+    end
+  end
+end
+```
+
+### Tracking Scrubbed Records
+
+By default, Purrrge will scrub records based on their creation date and any other criteria you define. However, this can lead to inefficiency as the same records may be processed in each scrubbing run.
+
+To optimize this process, Purrrge supports tracking scrubbed records with a `scrubbed_at` timestamp.
+
+#### Adding the `scrubbed_at` Column
+
+Add a `scrubbed_at` datetime column to your model:
+
+```ruby
+# Generate the migration
+rails generate purrrge:add_scrubbed_at MODEL_NAME
+
+# Run the migration
+rails db:migrate
+```
+
+This creates a migration that adds both the column and an index for performance:
+
+```ruby
+add_column :your_table_name, :scrubbed_at, :datetime
+add_index :your_table_name, :scrubbed_at
+```
+
+#### How It Works
+
+When the `scrubbed_at` column exists:
+
+1. Purrrge automatically sets `scrubbed_at = Time.current` when `scrub!` is called on a record
+2. Your query scopes can filter out already-scrubbed records with `WHERE scrubbed_at IS NULL`
+
+#### Implementation Example
+
+```ruby
+# Model definition
+class User < ApplicationRecord
+  include Purrrge::Scrubbable
+
+  # Define fields to scrub
+  scrub_field :email, scrub_value: nil
+  scrub_field :name, scrub_value: "REDACTED"
+  scrub_field :phone, scrub_value: "xxx-xxx-xxxx"
+
+  # Optional: Add your own custom callbacks to run after scrubbing
+  after_scrub :log_scrubbing_event
+
+  private
+
+  def log_scrubbing_event
+    Rails.logger.info "User #{id} was scrubbed at #{scrubbed_at}"
+  end
+end
+
+# In your scrubbing service
+def scrub_user_data(organization, retention_date)
+  # Only select records that haven't been scrubbed yet
+  users = organization.users.where("created_at < ? AND scrubbed_at IS NULL", retention_date)
+
+  users.find_in_batches do |batch|
+    batch.each(&:scrub!)
+  end
+end
+```
+
+#### Fallback Behavior
+
+If the `scrubbed_at` column doesn't exist on a model, Purrrge will still work normally - it just won't track which records have been scrubbed.
+
+### Registry for Automatic Model Discovery
+
+Purrrge includes a Registry system that automatically keeps track of all models that include the `Scrubbable` concern. This makes it easy to implement application-wide data retention policies.
+
+#### How it Works
+
+When a model includes the `Purrrge::Scrubbable` concern, it's automatically registered with `Purrrge::Registry`. You can then discover and process all scrubbable models in your application.
+
+```ruby
+# Get all registered scrubbable models
+scrubbable_models = Purrrge::Registry.scrubbable_models
+
+# Discover all scrubbable models in a Rails application
+# (This will eager load models and find those that include Purrrge::Scrubbable)
+all_models = Purrrge::Registry.discover_models
+```
+
+#### Using the Registry
+
+The Registry is designed to be application-agnostic and doesn't impose any specific data model. Here are some general ways to use it:
+
+```ruby
+# Get all registered scrubbable models
+models = Purrrge::Registry.scrubbable_models
+
+# Process each model according to your application's requirements
+models.each do |model|
+  # Implement your application-specific logic here
+  # This could involve filtering records based on dates, categories,
+  # or any other business logic relevant to your application
+  
+  # Example: Finding records older than a certain date
+  if model.respond_to?(:created_at)
+    records = model.where('created_at < ?', 1.year.ago)
+    records.find_in_batches(batch_size: 1000) do |batch|
+      batch.each(&:scrub!)
+    end
+  end
+end
+```
+
+#### Extending with Custom Behavior
+
+You can define custom class methods on your models to standardize how records are selected for scrubbing:
+
+```ruby
+# Example custom methods for your models
+class User < ApplicationRecord
+  include Purrrge::Scrubbable
+  
+  scrub_field :email, scrub_value: nil
+  
+  # Custom method for finding records to scrub
+  def self.scrubbable_records(cutoff_date)
+    where('created_at < ?', cutoff_date)
+  end
+end
+
+# Using the custom method in a worker
+Purrrge::Registry.scrubbable_models.each do |model|
+  if model.respond_to?(:scrubbable_records)
+    records = model.scrubbable_records(1.year.ago)
+    records.find_in_batches(batch_size: 1000) do |batch|
+      batch.each(&:scrub!)
+    end
+  end
+end
+```
+
+#### Testing the Registry
+
+For testing purposes, you can clear the registry:
+
+```ruby
+# Clear registry between tests
+Purrrge::Registry.clear
+```
+
+#### Configuration Options
+
+When defining fields to be scrubbed, you have several options:
+
+1. **Set to a specific value**:
+   ```ruby
+   scrub_field :email, scrub_value: nil
+   scrub_field :name, scrub_value: "REDACTED"
+   ```
+
+2. **Use a custom method**:
+   ```ruby
+   scrub_field :address, scrub_method: :anonymize_address
+   
+   def anonymize_address(field)
+     self[field] = "#{self.country}, #{self.state}" # Keep only country and state
+   end
+   ```
+
+#### Callback Hooks
+
+Purrrge provides callback hooks that allow you to execute code before and after scrubbing occurs:
+
+```ruby
+class User
+  include Purrrge::Scrubbable
+  
+  scrub_field :email, scrub_value: nil
+  scrub_field :name, scrub_value: "REDACTED"
+  
+  # Register callbacks
+  before_scrub :log_scrubbing_event
+  before_scrub :notify_admin, if: :admin_user?
+  after_scrub :update_scrubbed_timestamp
+  
+  private
+  
+  def log_scrubbing_event
+    Rails.logger.info("Scrubbing user data for User ##{id}")
+    # Return false to halt the callback chain and prevent scrubbing
+    true
+  end
+  
+  def notify_admin
+    AdminMailer.user_data_scrubbed(self).deliver_later
+  end
+  
+  def admin_user?
+    role == 'admin'
+  end
+  
+  def update_scrubbed_timestamp
+    update_column(:scrubbed_at, Time.current)
+  end
+end
+```
+
+Callbacks support conditions via `:if` and `:unless` options, which can be:
+- Symbol naming an instance method
+- Proc or lambda
+- Array of symbols or procs
+
+If a `before_scrub` callback returns `false`, the scrubbing operation will be halted.
+
+#### Working with Different ORMs
+
+Purrrge is designed to be ORM-agnostic. While it works great with ActiveRecord, you can use it with any Ruby class that:
+
+1. Has attribute accessors for the fields you want to scrub
+2. Implements a `save` method
+
+For non-ActiveRecord classes, just ensure you implement these requirements:
+
+```ruby
+class MyCustomModel
+  include Purrrge::Scrubbable
+  
+  attr_accessor :name, :email
+  
+  scrub_field :email, scrub_value: nil
+  
+  def save(options = {})
+    # Your custom save implementation
+    true
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+### Semantic Versioning
+
+The gem follows [Semantic Versioning](https://semver.org/) principles. When creating pull requests, please indicate the type of change:
+
+- **PATCH** version for backwards-compatible bug fixes
+- **MINOR** version for backwards-compatible new features
+- **MAJOR** version for breaking changes
+
+Our CI system will automatically determine the appropriate version bump based on commit messages and PR descriptions.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/grayscaleapp/purrrge.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`) 
+   - Use conventional commit messages: `feat:`, `fix:`, `docs:`, etc.
+   - Prefix breaking changes with `BREAKING CHANGE:` or include `MAJOR` in the description
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request using the provided template

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/generators/purrrge/add_scrubbed_at_generator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Purrrge
+  module Generators
+    class AddScrubbedAtGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      # Implementation of the required interface for Rails::Generators::Migration
+      def self.next_migration_number(dirname)
+        ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def create_migration_file
+        migration_template "add_scrubbed_at_migration.rb.erb",
+                           "db/migrate/add_scrubbed_at_to_#{table_name}.rb"
+      end
+
+      private
+
+      def table_name
+        name.underscore.pluralize
+      end
+    end
+  end
+end

data/lib/generators/purrrge/templates/add_scrubbed_at_migration.rb.erb

@@ -0,0 +1,6 @@
+class AddScrubbedAtTo<%= class_name.pluralize %> < ActiveRecord::Migration<%= Rails::VERSION::MAJOR >= 5 ? "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]" : "" %>
+  def change
+    add_column :<%= table_name %>, :scrubbed_at, :datetime
+    add_index :<%= table_name %>, :scrubbed_at
+  end
+end 

data/lib/purrrge/registry.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Purrrge
+  # Registry tracks models that include the Scrubbable concern.
+  # It provides methods for registration and discovery of scrubbable models.
+  #
+  # This is used by automatic discovery mechanisms to find models that can be scrubbed
+  # without requiring explicit configuration.
+  class Registry
+    class << self
+      # Get all registered scrubbable models
+      #
+      # @return [Array<Class>] Array of model classes that include Purrrge::Scrubbable
+      def scrubbable_models
+        @scrubbable_models ||= []
+      end
+
+      # Register a model class with the registry
+      #
+      # @param model_class [Class] The model class to register
+      # @return [Array<Class>] The updated array of scrubbable models
+      def register(model_class)
+        scrubbable_models << model_class unless scrubbable_models.include?(model_class)
+        scrubbable_models
+      end
+
+      # Clear the registry (mainly for testing)
+      #
+      # @return [Array] An empty array
+      def clear
+        @scrubbable_models = []
+      end
+
+      # Discover all models that include Scrubbable in a Rails application
+      # This method eager loads all models in the Rails app and finds those
+      # that include the Scrubbable concern.
+      #
+      # @return [Array<Class>] Array of discovered model classes
+      def discover_models
+        return [] unless defined?(Rails)
+
+        # Eager load all models if not in production (where eager loading is the default)
+        Rails.application.eager_load! unless Rails.application.config.eager_load
+
+        # Find all ActiveRecord models that include Purrrge::Scrubbable
+        if defined?(ActiveRecord::Base)
+          # Get all models that include Scrubbable
+          scrubbable = ActiveRecord::Base.descendants.select do |model|
+            model.included_modules.include?(Purrrge::Scrubbable)
+          end
+
+          # Register each one
+          scrubbable.each do |model|
+            register(model)
+          end
+        end
+
+        scrubbable_models
+      end
+    end
+  end
+end

data/lib/purrrge/scrubbable.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/core_ext/class/attribute"
+require "active_support/callbacks"
+
+module Purrrge
+  # Scrubbable is a concern that provides functionality for data scrubbing/anonymization.
+  # It allows the implementing class to define which fields should be scrubbed
+  # and how they should be scrubbed (either by setting to a specific value or using a custom method).
+  #
+  # Usage:
+  #
+  #   class User
+  #     include Purrrge::Scrubbable
+  #
+  #     scrub_field :email, scrub_value: nil
+  #     scrub_field :name, scrub_value: "REDACTED"
+  #     scrub_field :phone, scrub_method: :anonymize_phone
+  #
+  #     def anonymize_phone(field)
+  #       self[field] = "xxx-xxx-xxxx"
+  #     end
+  #   end
+  #
+  module Scrubbable
+    extend ActiveSupport::Concern
+    include ActiveSupport::Callbacks
+
+    included do
+      # Auto-register with Registry when included
+      Purrrge::Registry.register(self) if defined?(Purrrge::Registry)
+
+      class_attribute :scrubbable_fields, default: []
+
+      # Define callbacks
+      define_callbacks :scrub
+    end
+
+    class_methods do
+      # Registers a field to be scrubbed
+      #
+      # @param field_name [Symbol] The name of the field to scrub
+      # @param scrub_value [Object] The value to set the field to when scrubbing (optional)
+      # @param scrub_method [Symbol] The name of a method to call for custom scrubbing (optional)
+      #
+      # @example
+      #   scrub_field :email, scrub_value: nil
+      #   scrub_field :phone, scrub_method: :anonymize_phone
+      def scrub_field(field_name, scrub_value: nil, scrub_method: nil)
+        scrubbable_fields << {
+          field: field_name,
+          value: scrub_value,
+          method: scrub_method
+        }
+      end
+
+      # Registers a callback to be called before scrubbing
+      #
+      # @param method_name [Symbol] The name of the method to call
+      # @param options [Hash] Options to pass to the callback
+      #
+      # @example
+      #   before_scrub :do_something
+      def before_scrub(method_name, options = {})
+        set_callback :scrub, :before, method_name, options
+      end
+
+      # Registers a callback to be called after scrubbing
+      #
+      # @param method_name [Symbol] The name of the method to call
+      # @param options [Hash] Options to pass to the callback
+      #
+      # @example
+      #   after_scrub :clean_external_services
+      def after_scrub(method_name, options = {})
+        set_callback :scrub, :after, method_name, options
+      end
+    end
+
+    # Performs the actual scrubbing operation on all registered fields
+    #
+    # @return [Boolean] Returns the result of the save operation
+    def scrub!
+      run_callbacks :scrub do
+        self.class.scrubbable_fields.each do |field_config|
+          if field_config[:method]
+            send(field_config[:method], field_config[:field])
+          else
+            self[field_config[:field]] = field_config[:value]
+          end
+        end
+
+        # Automatically set scrubbed_at timestamp if the column exists
+        if respond_to?(:scrubbed_at=) && self.class.respond_to?(:column_names) && self.class.column_names.include?("scrubbed_at")
+          self.scrubbed_at = Time.now
+        end
+
+        save(validate: false)
+      end
+    end
+
+    # Override the [] method to provide access to attributes
+    # This allows the gem to be database-agnostic
+    def [](field)
+      return unless respond_to?(field)
+
+      send(field)
+    end
+
+    # Override the []= method to set attributes
+    # This allows the gem to be database-agnostic
+    def []=(field, value)
+      return unless respond_to?("#{field}=")
+
+      send("#{field}=", value)
+    end
+  end
+end

data/lib/purrrge/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Purrrge
+  VERSION = "1.5.0"
+end

data/lib/purrrge.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "purrrge/version"
+require_relative "purrrge/registry"
+require_relative "purrrge/scrubbable"
+
+# Only require the generator if Rails is defined
+require_relative "generators/purrrge/add_scrubbed_at_generator" if defined?(Rails::Generators)
+
+module Purrrge
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/purrrge.rbs

@@ -0,0 +1,4 @@
+module Purrrge
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: purrrge
+version: !ruby/object:Gem::Version
+  version: 1.5.0
+platform: ruby
+authors:
+- Cody Stamps
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Purrrge provides tools for implementing data retention policies and scrubbing
+  sensitive data in compliance with privacy regulations.
+email:
+- cody.stamps@grayscaleapp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".semaphore/semaphore.yml"
+- ".semaphore/version-and-tag.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/generators/purrrge/add_scrubbed_at_generator.rb
+- lib/generators/purrrge/templates/add_scrubbed_at_migration.rb.erb
+- lib/purrrge.rb
+- lib/purrrge/registry.rb
+- lib/purrrge/scrubbable.rb
+- lib/purrrge/version.rb
+- sig/purrrge.rbs
+homepage: https://github.com/grayscaleapp/purrrge
+licenses: []
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/grayscaleapp/purrrge
+  source_code_uri: https://github.com/grayscaleapp/purrrge
+  changelog_uri: https://github.com/grayscaleapp/purrrge/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: A data retention and scrubbing library for Ruby applications
+test_files: []