Adds magic creator and updater attributes to your ActiveRecord models.
Pull request Compare This branch is 11 commits ahead, 9 commits behind insphire:master.
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.
lib Use before_action and after_action in controller mixins Jul 4, 2016
rdoc improve readme Aug 9, 2010
.gitignore Ignore Gemfile.lock Sep 13, 2016
CHANGELOG v3.0 Sep 13, 2016
Gemfile Cleanup Gemfile and Rakefile Sep 13, 2016
LICENSE Doing a bit of reorganization of the repository. Mar 3, 2008
Rakefile Cleanup Gemfile and Rakefile Sep 13, 2016
Readme.rdoc Update fork details in README Sep 13, 2016
VERSION v3.0 Sep 13, 2016
magiclabs-userstamp.gemspec Use before_action and after_action in controller mixins Jul 4, 2016



Fork Details

This is a fork of the grosser fork [] of the original userstamp plugin created by delynn [].

This fork has been created to combine the grosser changes that enable use of the plugin within applications that perform soft deletes but are not using the acts_as_paranoid plugin/gem (for example this fork can now be used in conjunction with the rails3_acts_as_paranoid plugin/gem []).

This fork also includes changes to perform the model stamping before validation is performed so that the model can enforce the presence of stamp attribute values eg.

validates :created_by, presence: true
validates :updated_by, presence: true

Using the Fork

To use this fork add the following to your application gemfile:

gem 'magiclabs-userstamp', github: 'magiclabs/userstamp'


Userstamp extends ActiveRecord::Base to add automatic updating of 'creator', 'updater', and 'deleter' attributes. It is based loosely on the ActiveRecord::Timestamp module.

Two class methods (model_stamper and stampable) are implemented in this plugin. The model_stamper method is used in models that are responsible for creating, updating, or deleting other objects. The stampable method is used in models that are subject to being created, updated, or deleted by 'stampers'.


The assumption is that you have two different categories of objects; those that manipulate, and those that are manipulated. For those objects that are being manipulated there's the Stampable module and for the manipulators there's the Stamper module. There's also the actual Userstamp module for your controllers that assists in setting up your environment on a per request basis.


Assume a weblog application has User and Post objects. # 1: Create the migrations for these objects

class CreateUsers < ActiveRecord::Migration
  def self.up
    create_table :users, :force => true do |t|
      t.userstamps # use t.userstamps(true) if you also want 'deleter_id'
  def self.down
    drop_table :users
class CreatePosts < ActiveRecord::Migration
  def self.up
    create_table :posts, :force => true do |t|
      t.userstamps # use t.userstamps(true) if you also want 'deleter_id'
  def self.down
    drop_table :posts

# 2: Users are going to manipulate Post's, use the model_stamper:

class User < ActiveRecord::Base

# 3: Set the current user in the ApplicationController:

class ApplicationController < ActionController::Base
  include Userstamp

More than likely you want all your associations setup on your stamped objects, and that's where the stampable class method comes in. So in our example we'll want to use this method in both our User and Post classes:

class User < ActiveRecord::Base
class Post < ActiveRecord::Base

Okay, so what all have we done? The model_stamper class method injects two methods into the User class. They are #stamper= and #stamper and look like this:

def stamper=(object)
  object_stamper = if object.is_a?(ActiveRecord::Base)
  Thread.current["#{self.to_s.downcase}_#{self.object_id}_stamper"] = object_stamper
def stamper

The stampable method allows you to customize what columns will get stamped, and also creates the creator, updater, and deleter associations.

The Userstamp module that we included into our ApplicationController uses the setter method to set which user is currently making the request. By default the 'set_stampers' method works perfectly with the RestfulAuthentication plug-in:

def set_stampers
  User.stamper = self.current_user

If you aren't using ActsAsAuthenticated, then you need to create your own version of the set_stampers method in the controller where you've included the Userstamp module.

Now, let's get back to the Stampable module (since it really is the interesting one). The Stampable module sets up before_* filters that are responsible for setting those attributes at the appropriate times. It also creates the belongs_to relationships for you.

If you need to customize the columns that are stamped, the stampable method can be completely customized. Here's an quick example:

class Post < ActiveRecord::Base
  stampable :stamper_class_name => :person,
            :creator_attribute  => :create_user,
            :updater_attribute  => :update_user,
            :deleter_attribute  => :delete_user,

:deleter => true


Upgrade from 1.x

# config/environment.rb
Ddb::Userstamp.compatibility_mode = true

Example userstamp application

Running Unit Tests

All: rake
One: ruby test/compatibility_stamping_test.rb


DeLynn Berry

The original idea for this plugin came from the Rails Wiki article entitled Extending ActiveRecord.

Contributors / maintenance / enhancement